AI for Data Analysts That Knows Your Schema

Updated January 2026 | 8 min read

You need a report on monthly recurring revenue by customer segment. You ask AI to write the SQL.

It gives you a query that looks reasonable. You run it. Error: table 'customers' doesn't exist. Your table is called 'accounts'. And MRR isn't a field — it's calculated from subscription_value and billing_frequency. And "customer segment" in your database is stored as tier_id, not segment_name.

You paste your schema. Explain the MRR calculation. Clarify the tier mapping. AI re-writes the query. Closer, but it's joining on user_id when it should join on account_id because your users table is different from your accounts table.

Twenty minutes later, you've got working SQL. Tomorrow, different report, same problem — AI forgot your schema. You start over.

Data analysts don't need AI that writes generic SQL. They need AI that knows their database.

Why Does Generic AI Fail Data Analysts?

ChatGPT can write SQL. It just can't write your SQL.

It doesn't know your schema. It doesn't know your business logic. It doesn't know how your tables relate, what your naming conventions are, or what fields mean in your company's context.

Data analysts are working with:

• Database schemas (table names, field names, data types, relationships)
• Business logic (how revenue is calculated, what "active user" means, how churn is defined)
• Reporting formats (what stakeholders want to see, how data should be grouped, what's a metric vs. a dimension)
• Data quality issues (which fields are reliable, which have null problems, which need cleaning)
• Common queries (monthly reports that run the same way every time, dashboards that pull the same data)

When you ask AI to write a query, it guesses. Table names, field names, join logic — all guesses. Sometimes it's close. Usually it's wrong.

The AI can write SQL. It just doesn't know what to write it about.

What Data Analysts Actually Need

You need AI that remembers:

Your database schema. Not generic examples — your actual tables, fields, data types, primary keys, foreign keys, indexes. AI should know that 'accounts' exists but 'customers' doesn't.

Your business logic. How revenue is calculated. What "active user" means (logged in last 30 days? Made a purchase? Opened the app?). How churn is defined. What fields feed into what metrics.

Your table relationships. How users relate to accounts. How transactions relate to subscriptions. What joins work and what joins create duplicates. Which fields are reliable foreign keys and which aren't.

Your reporting standards. How stakeholders want data formatted. What date ranges default reports use. What gets rounded and to how many decimals. What gets grouped by month vs. week vs. day.

Your data quirks. The legacy field that's no longer updated. The table that has null problems. The join that's slow and should be avoided. The calculation that looks simple but has edge cases.

Generic AI can't do this. It needs context files.

How Context Files Work for Data Analysts

Context files are markdown documents that live in Obsidian. AI reads them every time you start a conversation.

One file might be database-schema.md:

• Table names and what they store
• Field names, data types, descriptions
• Primary keys and foreign keys
• Common joins and relationships
• Tables to avoid (deprecated, slow, unreliable)

Another might be business-logic.md:

• How key metrics are calculated (MRR, churn, LTV, CAC)
• Business definitions (what's an active user, what's a qualified lead)
• Segmentation logic (how customers are grouped)
• Edge cases and exceptions

Another: reporting-standards.md:

• How stakeholders want data formatted
• Default date ranges for monthly/quarterly reports
• Grouping and aggregation preferences
• Chart types and visualization standards

When you ask AI to write SQL for MRR by segment, it reads database-schema.md (knows the accounts table, subscription_value field, tier_id mapping), reads business-logic.md (knows how to calculate MRR from subscription_value and billing_frequency), and reads reporting-standards.md (knows stakeholders want monthly grouping, rounded to nearest dollar).

First query works. No schema pasting. No re-explaining business logic. Just working SQL.

Before and After

Before: "Write SQL for MRR by customer segment."
AI writes a query using table 'customers' (doesn't exist), field 'mrr' (doesn't exist), and 'segment' (stored as tier_id).

You paste schema. Explain MRR calculation. Clarify tier mapping. AI re-writes. Now it joins on user_id instead of account_id. You fix the join. Run it. Works, but slow because it's querying a deprecated table.

You've spent 20 minutes getting working SQL. Tomorrow, different report — you start over.

After: "Write SQL for MRR by customer segment."
AI reads database-schema.md, business-logic.md, and reporting-standards.md. First query: pulls from accounts table, calculates MRR correctly, joins on account_id, groups by tier_id, formats output as stakeholders expect. You run it. Works.

Next request: "Add churn rate to that report."
AI knows how churn is calculated (from business-logic.md), knows which fields to use, adds it to the query. Another working first draft.

No re-explaining. No schema pasting. AI remembers.

What This Looks Like in Practice

A data analyst at a SaaS company sets up four context files:

1. database-schema.md — All tables, fields, relationships, data types
2. business-logic.md — Metric definitions, calculations, segmentation rules
3. reporting-standards.md — Stakeholder preferences, formatting rules, default date ranges
4. common-queries.md — Frequently-run reports and their SQL patterns

Total setup time: one afternoon (mostly copy-pasting existing documentation).

Now when she asks AI to write SQL, it knows the schema, the business logic, and the reporting standards. When she asks for Python to clean data, AI knows which fields have null problems. When she asks for a dashboard query, AI knows what stakeholders want to see.

When the schema changes (new table added, field renamed), she updates database-schema.md. Every future query uses the new schema. When business logic changes (new MRR calculation, different churn definition), she updates business-logic.md. AI adjusts automatically.

The context files become the data dictionary. New analysts read them for onboarding. AI reads them for every query. Stakeholders read them to understand where numbers come from.

What You Get

AI that writes SQL using your actual schema, not guesses.

AI that calculates metrics using your business logic, not generic formulas.

AI that formats reports the way stakeholders expect without being told.

AI that avoids data quality issues, slow tables, and deprecated fields.

AI that gets smarter as you update schema docs and business logic.

No more pasting schemas. No more re-explaining calculations. No more fixing broken queries that almost worked.

Data analysts already document schemas and business logic (or should). This just makes AI read it.

When This Isn't the Right Move

The $997 AI memory setup isn't for everyone. Skip it if:

• You use AI once a week or less. If AI is an occasional tool rather than a daily workflow, the investment doesn't pay back fast enough. Start with ChatGPT's free Custom Instructions instead.
• You're happy with generic AI output. If you don't need AI to match your specific voice, processes, or terminology, the built-in memory features of ChatGPT or Claude Projects may be sufficient.
• Your practice workflows change monthly. The memory file works best when your core processes are stable enough to document. If you're still figuring out your approach, wait until it solidifies.

This is designed for Data Analysts who use AI daily and are tired of re-explaining their practice every session. If that's not you yet, the free guide covers how to start smaller.

Frequently Asked Questions

How long does it take to set up AI memory for Data Analysts?

The initial setup takes about 90 minutes. You document your workflows, terminology, client types, and communication style into a structured markdown file. After that, every AI conversation starts with your professional context loaded automatically.

Do I need technical skills to use an AI memory system?

No. The memory file is plain text in markdown format — similar to writing notes. You don't need to code, use APIs, or configure complex software. The setup session walks you through everything, and the result is a single file you can edit in any text editor.

Will AI memory work with my existing tools and software?

The memory system works alongside your current tools, not instead of them. Claude Code reads your context file locally — your data stays on your machine. It doesn't require integration with your EHR, CRM, or practice management software. You use it as a standalone AI assistant that happens to know your business.