Implementing Generative Analytics with Thesys and MCP
In the last blog post we covered why static analytics interfaces are fundamentally broken. They force users into rigid workflows designed by developers who try to anticipate every possible use case. The result? Complex dashboards with dozens of options, most of which are irrelevant to any given analytical question.
Real businesses don't work this way. When you ask a sales director about quarterly performance, they don't pull up a predetermined dashboard. They think through your question and request the right view - a revenue trend chart, regional breakdown, or pipeline funnel.
Every analytical question needs a different interface:
- Quarterly sales performance ≠ Regional breakdown ≠ Product mix analysis
- Revenue trends ≠ Customer segmentation ≠ Market share comparison
- Sales forecasting ≠ Territory optimization ≠ Pipeline analysis
Traditional approaches force developers to build separate interfaces for each scenario, leading to bloated codebases and inconsistent user experiences.
The Generative Solution
Generative UI transforms analytics from static dashboards to dynamic conversations. Instead of predetermined interfaces, your application generates the perfect UI component for each analytical question:
- Turn-based workflow: User asks → System generates perfect UI → User interacts → Asks follow-up → Gets next perfect UI
- Context awareness: Each response builds on previous interactions and learned user preferences
- Professional workflow: Mirrors how real analysts work through complex problems step-by-step
The impact is transformative. Development teams report 4x faster iteration cycles because they're not building custom interfaces for every analytical scenario. Users complete analytical tasks 60% faster because they get exactly the interface they need without navigating complex dashboards.
More importantly, this approach scales infinitely. One system handles every possible analytical scenario without requiring developers to anticipate and code for each use case.
How C1 by Thesys + MCP Creates Analytical Intelligence
The magic happens through the combination of:
- C1 Generative UI API serves as the brain that transforms analytical queries into appropriate interface components. Unlike traditional APIs that return data, C1 returns fully-formed UI elements: charts, tables, forms, and interactive components tailored to the specific analytical question.
- Model Context Protocol (MCP) servers that provide standardized connections to data sources. For financial analytics, this means real-time market data, historical prices, fundamental metrics, and complex calculations - all accessible through consistent, OpenAI-compatible tool calling patterns.
The Workflow Architecture
Here's how the system orchestrates intelligent analytical responses:
- User asks analytical question in natural language
- System determines required data through intelligent MCP routing
- C1 generates appropriate interface based on query type and context
- User interacts with generated UI (clicks, inputs, selections)
- Cycle continues with context awareness, building analytical depth
Real Scenarios in Action
Imagine you are a sales leader and want to know, "Quarterly sales for Microsoft."
The system recognizes this as a performance inquiry and generates a clean bar graph showing quarterly revenue progression. The visualization is immediately clear and focused - no clutter, no unnecessary options, just the exact chart needed to answer your specific question.
Now say you want to "Split it by region."
Instead of starting over or navigating to a different dashboard, the existing chart seamlessly morphs into a bar visualization with distinct sections for each region. North America, Europe & Asia-Pacific - the data reorganizes itself to match your analytical thinking process.
C1 can handle every single data-related question, every drilldown, every filter. Looking at the Americas segment you might want to ask "Explain why US generates 67% of Microsoft's revenue"
The system generates a detailed breakdown showing product mix, seasonal factors, and key deal contributions. Follow up with "Compare to last year" and get an overlay comparison that maintains your regional focus while adding temporal context.
This isn't just convenience - it's a fundamental shift in how business intelligence works. Each question gets the perfect interface, each follow-up builds naturally on the previous insight, and the entire analytical journey flows like a conversation with a expert analyst.
Building Conversational Analytics Components
Data & Knowledge
Modern analytics requires more than just raw data - it needs context, definitions, and domain knowledge to generate meaningful insights. MCP servers solve this by providing standardized access to both structured data and knowledge repositories.
Knowledge Integration Patterns allow systems to combine multiple information sources seamlessly. When a user asks about "quarterly performance," the system can pull sales data from your CRM, financial data from your ERP, and market context from external APIs - all through consistent MCP interfaces.
Domain-Specific Knowledge becomes accessible through specialized MCP servers. Financial terminology, industry benchmarks, regulatory context, and business definitions can be integrated alongside quantitative data, ensuring generated interfaces include appropriate context and explanations.
Real-Time Knowledge Updates keep analytics current with changing business conditions. MCP servers can provide access to live data feeds, recent news, market conditions, and internal updates, ensuring every generated visualization reflects the most current business environment.
The power lies in composition: one query can trigger multiple MCP servers to gather comprehensive context. "How are we performing?" might pull sales data, market benchmarks, competitor information, and internal KPIs - then generate a response that synthesizes all perspectives into actionable insights.
Smart Context Management
Context is everything in conversational analytics. Unlike traditional APIs where each request is independent, analytical conversations build depth through multiple turns. The system must remember previous queries, learn user preferences, and maintain analytical threads across interactions.
Effective context management tracks:
- Conversation history: What questions led to the current query?
- User preferences: Org role, persona based personalizations go a long way in improving the user experience
- Analytical threads: Building complex analysis through multiple related queries
- Current focus: Active query, timeframes, or domain specific analytical frameworks
Multi-Step Analytical Workflows
Real analytics isn't one-shot queries - it's investigative workflows that build understanding through multiple related questions. The system must support natural analytical progressions while maintaining context and building complexity.
Stock Research Journey
A typical research workflow might unfold like this:
- "Tell me about Microsoft" → Basic overview card with current stock price, market cap, and recent company news from earnings reports
- "How's the quarterly performance?" → Clean bar chart showing revenue progression over the last 8 quarters with growth indicators
- "Split it by business segments?" → Stacked bar visualization breaking down revenue by Azure, Office, Windows, and other divisions
- "Compare to competitors?" → Side-by-side analysis table with Microsoft vs Google, Amazon, and Apple showing key financial metrics
Each step builds on the previous, creating a natural investigative flow that mirrors how professional analysts research investments.
Production Patterns That Scale
Advanced Integration Patterns
Smart Intent Detection goes beyond simple keyword matching to understand analytical intent. "Compare AAPL and GOOGL" versus "Which is better, AAPL or GOOGL?" represent different analytical approaches requiring different interfaces - comparison tables versus decision frameworks.
Context Enrichment automatically adds relevant data based on conversation flow. When users ask about a stock's performance, the system proactively includes sector context, peer comparisons, and market backdrop without explicit requests.
Fallback Strategies provide meaningful alternatives when primary workflows fail. If real-time data is unavailable, offer historical analysis. If complex calculations fail, provide simplified metrics with explanations.
Production Considerations
Rate Limiting and Cost Management become critical at scale. C1 token consumption, MCP server calls, and external data API usage must be monitored and optimized. Implement intelligent request batching, cache optimization, and user-based rate limiting to control costs while maintaining performance.
Error Handling with Helpful Alternatives transforms failure modes into opportunities. When market data APIs fail, offer cached analysis with clear timestamps. When calculations fail, provide simplified alternatives with explanations. Always give users productive next steps rather than dead ends.
Monitoring Popular Query Patterns enables continuous optimization. Track which analytical workflows users follow most frequently, where they encounter friction, and which generated interfaces perform best. Use this data to optimize prompts, preload common data patterns, and improve user experiences.
Getting Started: Your Implementation Guide
Prerequisites
Building conversational analytics requires foundational knowledge in several areas:
Technical Skills: Basic React knowledge for C1 by Thesys integration, API integration experience for MCP connections, and understanding of data analysis workflows to design effective user experiences.
Domain Knowledge: Familiarity with your analytical domain (finance, marketing, operations) to create meaningful user experiences and appropriate interface generation patterns.
Design Thinking: Understanding of progressive disclosure principles and conversational UI patterns to create intuitive analytical workflows.
Implementation Path
Phase 1: Foundation Setup Set up your MCP servers for data source connectivity. This involves configuring endpoints for your analytical data (market data, user analytics, business metrics) and implementing standardized tool calling patterns.
Configure C1 integration with OpenAI-compatible endpoints. This includes API key management, rate limiting setup, and basic prompt configuration for your analytical domain.
Phase 2: Core Workflows Build your conversation component with context management. This handles user input, conversation history, and the coordination between user queries and generated responses.
Define workflow patterns for common analytical scenarios. Start with 3-5 basic patterns like data lookup, comparison analysis, and trend investigation before expanding to complex multi-step workflows.
Phase 3: Progressive Enhancement Add progressive disclosure for complex workflows. Implement step-by-step form generation, conditional complexity reveals, and context-aware feature exposure.
Integrate advanced features like smart caching, error handling, and performance optimization as your user base grows.
Quick Wins for Immediate Impact
- Start with Simple Query Types like price lookups, basic comparisons, and data summaries. These provide immediate value while you build more sophisticated workflows.
- Focus on Conversation Flow over feature creep initially. Resist the temptation to build more dashboard-like features and rather focus on composition and domain specific intelligence.
- Implement 80/20 Coverage by identifying the most common analytical questions in your domain and building excellent experiences for those before expanding to edge cases.
Common Pitfalls to Avoid
- Don't try to optimize for every possible query on day one. Start with 3-5 common analytical patterns and let C1 handle the fallbacks. Optimize based on user feedback over time.
- Avoid over-engineering context management initially. Simple conversation history and basic preference tracking provide 80% of the value with 20% of the complexity.
- Don't neglect error handling and fallbacks. External APIs fail, data sources go offline, and users ask unexpected questions. Graceful degradation is essential for production systems.
Ready to Build
The architecture is straightforward: MCP servers standardize your data access, C1 generates intelligent interfaces, and context management ties it all together. Start with your three most common analytical questions and build from there.
You don’t need to replace every dashboard overnight to see impact. Start with your top 3 use cases - and scale with confidence.. The technical patterns are proven, the implementation path is clear, and the competitive advantage is significant.
Link to functional demo here
Complete source code is available at Github
Head over today to start building your own - $10 in credits for new signups