LLMs in Data Analytics: Reality vs. Hype

Understanding LLMs in Analytics

Large Language Models (LLMs) like ChatGPT, Bard, and others have revolutionized many aspects of data analytics. They promise to automate tasks, provide instant insights, and democratize access to data analysis. But how much of this is reality, and what remains hype? This guide explores the full spectrum—from their strengths and weaknesses to practical strategies for accurate, efficient analytics.

What Are LLMs and How Do They Work?

LLMs are AI models trained on massive datasets, including text, code, and documentation. They generate human-like responses, making them ideal co-pilots for analysts who need code snippets, explanations, or quick data summaries. However, their probabilistic nature means they predict the next best token rather than guaranteeing factual accuracy.

Common Expectations vs. Real-World Performance

• Expectation: Plug in your enterprise data, ask a question, and get perfect analysis instantly.
• Reality: LLMs can hallucinate—making up convincing but incorrect answers, especially in complex or unfamiliar contexts.

Why Do LLMs Hallucinate?

LLMs calculate the probability of the next word or token based on their training. When context is missing or ambiguous, they fill gaps with plausible but sometimes inaccurate information. This is particularly risky in analytics, where even minor errors can have major consequences.

Case Studies: LLMs Getting It Wrong

1. Difference-in-Differences Analysis: An LLM provided a credible-looking but subtly incorrect algorithm, swapping variables and producing incorrect results.
2. Financial Forecasting: During a high-profile Bing Chat demo analyzing Gap Inc.'s stock, the model generated entirely incorrect figures for revenue, earnings, and forecasts—all presented confidently.

LLMs and Math: A Difficult Relationship

Although LLMs excel at generating code due to its structured syntax, they often struggle with mathematics and numerical analysis. This is because math requires deterministic reasoning, while LLMs are fundamentally probabilistic and language-based.

Strengths of LLMs in Analytics

• Code Generation: LLMs are adept at producing SQL, Python, and DAX code, especially when provided with clear context.
• Documentation Assistance: They excel at generating explanations and documentation for code snippets.
• Testing and QA: LLMs can help create test datasets and cases for database validation.

Limitations and Risks

• Overconfidence: LLMs often present incorrect answers with high confidence, requiring human oversight.
• Context Dependence: Accurate outputs depend on providing precise, relevant context—such as schema, metadata, and business rules.
• Complex Data Models: Real-world data warehouses are messy, with inconsistent schemas, technical debt, and business logic that LLMs can't infer without guidance.

Human in the Loop: Essential for Accuracy

LLMs function best as junior analysts or co-pilots. Their outputs should always be reviewed by experienced analysts to catch subtle errors, ensure correct logic, and validate results before decision-making.

Optimizing LLM Performance: Key Strategies

1. Fine-Tuning:

• Retrain LLMs on your specific datasets to improve domain accuracy.
• Resource-intensive, requiring specialized hardware and expertise.
• Best for organizations with unique, proprietary data.

1. Retrieval Augmented Generation (RAG):

• Provide relevant context—like code bases, metadata, table schemas, and business logic—directly to the LLM via the prompt.
• Improves accuracy by narrowing the problem space.

1. Function Calling and Tool Integration:

• Allow LLMs to hand off complex calculations to external tools like Python or SQL engines.
• Reduces the risk of mathematical errors and hallucinated results.

1. Semantic Modeling:

• Leverage semantic layers (e.g., dbt models, data catalogs) to provide LLMs with clear relationships between tables, columns, and metrics.
• Critical for navigating real-world data environments with technical debt and inconsistent schemas.

Example: Improving Code Generation with Context

Suppose you need a DAX measure in Power BI. An LLM might initially generate incorrect code. By supplying table structure, sample data, and error messages, iterative refinement with the model increases accuracy—often reaching 80% correctness after a few rounds.

// Example prompt structure: "Given table 'sales' with columns date, product_id, revenue, and table 'products' with columns id, category, provide a DAX measure for total revenue by category." 

Real-World Best Practices for LLM-Driven Analytics

• Always provide rich, accurate context (metadata, schema, sample data).
• Use LLMs for initial drafts, then review and refine outputs.
• Leverage fine-tuning or RAG for complex, domain-specific tasks.
• Integrate with semantic layers to clarify business logic and data relationships.
• Employ human oversight for critical decisions and validation.

Current Use Cases Where LLMs Shine

• QA and documentation: Explaining code, documenting functions, and summarizing logic.
• Co-pilot analytics: Generating code drafts, automating simple analysis tasks, and suggesting test cases.
• Database testing: Creating fake data and connection tests based on metadata.
• Self-service analytics for straightforward queries, especially when paired with robust semantic modeling.

Challenges: When to Be Cautious

• Complex financial modeling and advanced statistical analysis—LLMs can miss subtle but critical details.
• Messy or undocumented data warehouses—risk of incorrect joins or misinterpretation of columns.
• Business-critical decisions—always require human validation and in-depth review.

How Keboola Supercharges LLMs for Analytics

Keboola’s platform unifies your data, context, and tools—bridging the gap between LLM capabilities and reliable analytics. With built-in support for semantic layers, metadata integration, and code generation workflows, you get:

• Instant context delivery to LLMs for accurate outputs.
• Seamless integration with code, documentation, and testing pipelines.
• Automated data lineage and governance to keep models grounded in business reality.
• Collaboration features ensuring human oversight and review at every step.

Getting Started: Proven Steps for Success

1. Centralize your metadata and schemas in Keboola.
2. Define semantic models to clarify business rules and data relationships.
3. Connect LLMs to Keboola’s platform for context-rich prompts and workflows.
4. Set up review and approval processes to ensure accuracy and compliance.

Conclusion: LLMs Are Powerful Co-Pilots—With the Right Platform

LLMs can dramatically accelerate analytics and code generation, but only when paired with accurate context, robust semantic models, and vigilant human review. Keboola gives you everything you need to unlock their power—without the risks.