Seu agent lê planilhas (sem treinar nada)

Seu agent lê planilhas (sem treinar nada)

O problema (historicamente):

Agents são bons em texto.

Agent (currently): Input: "What's the customer's credit risk?" Agent: Calls LLM LLM: "I don't know, analyze the data yourself"

What agent CAN do: ✓ Chat with customer ✓ Understand intent ✓ Write professional emails ✓ Explain concepts

What agent CAN'T do: ✗ Read spreadsheet ✗ Predict from data ✗ Make business decisions based on numbers ✗ Handle tabular data (CSV, database, table)

Why agents fail at spreadsheets:

LLMs are trained on text (Wikipedia, books, code). NOT trained on business data (spreadsheets, databases).

Give LLM a spreadsheet: "Here's 1000 rows of customer data. Predict: Who will churn next month?"

LLM response: "I don't understand numbers. I see words and text. Numbers in context of text = I can do. Raw numbers in table = I can't do."

Why? LLMs don't "understand" data structure. They understand language structure. Table ≠ language.

Historical solution (painful):

Option A: Train your own model Time: 2-4 weeks (data prep, training, validation) Cost: $5,000-$50,000 Data needed: 1000+ labeled rows Expertise needed: ML engineer on staff Result: Custom model (good, but expensive)

Option B: Use third-party API Time: 1 day (integration) Cost: $100-1000/month Data: Upload to third party (privacy risk) Flexibility: Limited to their features Result: Works, but expensive and slow

Option C: Manual analysis Time: 1 hour per spreadsheet (analyst time) Cost: $50-200 per analysis Data: Stays private (good) Scalability: Doesn't scale Result: Works, but not automatable

Now (NVIDIA solution):

NVIDIA Structured Data Models: Time: 5 minutes (load data, get predictions) Cost: $0-10 (inference only, no training) Data: Stays on your servers (private) Expertise needed: Zero (just point at table) Result: Instant predictions (no training)

---

The breakthrough (what NVIDIA did)

What are Structured Data Models?

High-level:

Structured Data Models (SDMs) = LLMs pre-trained on tabular data + in-context learning

Why it matters:

• Pre-trained on millions of business datasets
• Understands table structure, patterns, correlations
• Learns from examples (not from training)
• Works instantly (no fine-tuning needed)
• Works on YOUR data (specific tables, databases)

How it works:

Step 1: Load your spreadsheet File: customer_data.csv Columns: age, income, credit_score, products_owned, defaults Rows: 500 customers

Agent: "I have customer data. Predict who will default."

Step 2: Show examples to model "Here are 10 customers who defaulted." Model reads 10 labeled rows (in-context learning)

Step 3: Make predictions "For these 50 new customers, what's default probability?" Model predicts (instantly)

Step 4: Return results Customer A: 87% default risk Customer B: 12% default risk Customer C: 45% default risk

Total time: <1 second Training needed: ZERO Accuracy: 85-92% (competitive with trained models)

The magic ingredient: In-context learning

Traditional ML: Model sees: 1000 examples → learns patterns → makes prediction (Learning happens during training phase)

In-context learning: Model sees: 10 examples → understands pattern → makes prediction (Learning happens during inference)

Advantage:

• No training phase needed
• Can adapt to new datasets instantly
• Works without labeled data (few-shot learning)
• Updates don't break old predictions (consistent)

The NVIDIA models (what's available)

TabICLv2 (single table):

Best for: Single spreadsheet predictions

Examples: ✓ Customer churn prediction (from customer table) ✓ Product recommendation (from purchase history) ✓ Price prediction (from product table) ✓ Lead scoring (from lead table)

Accuracy: 90-95% on tabular benchmarks Latency: <500ms per prediction Train time: 0 (zero-shot)

How to use: from nvidia_sdm import TabICLv2 model = TabICLv2()

Your spreadsheet

data = load_csv("customers.csv")

Show examples (optional)

examples = data.head(10) # 10 customer examples

Predict

predictions = model.predict( examples=examples, new_data=data.tail(100) # 100 new customers )

Result: Probabilities for 100 customers

KumoTabular (single table, alternative):

Best for: More complex patterns, stronger baseline

Difference from TabICLv2:

• Slightly slower (better accuracy)
• Better at non-linear relationships
• Good when data has weird patterns

Example: Predict salary from job data TabICLv2: "I see experience, education, title" KumoTabular: "I see experience, education, title, plus interactions" Result: KumoTabular more accurate (+3-5%)

Trade-off: Speed: TabICLv2 faster Accuracy: KumoTabular better

KumoRelational (whole database):

Best for: Predictions across multiple related tables

Example (E-commerce): Tables: - customers (id, age, country, signup_date) - orders (customer_id, product_id, amount, date) - products (id, category, price) - reviews (order_id, rating)

Question: "Will customer churn?"

KumoRelational: - Reads customer table - Joins with orders (purchase history) - Joins with products (preference patterns) - Joins with reviews (satisfaction signal) - Makes prediction using all relationships

Result: 95%+ accuracy (uses full context)

---

Your agent's new superpower (what you can build)

Use case 1: Lead scoring (sales automation)

Problem (currently):

Sales team has lead spreadsheet: Columns: company_size, industry, website_quality, email_response_time, previous_engagement, budget_signal, decision_maker_found

Decision: "Which leads should we call first?"

Old way:

• Sales manager reads spreadsheet manually (2-3 hours)
• Ranks leads subjectively
• Misses patterns (human bias)
• Slow and non-scalable

Solution (with SDM + agent):

Agent workflow:

1. Load lead spreadsheet (via API or file upload)
2. Show 20 examples of "high-value leads" (from CRM history)
3. Model learns: What makes a lead high-value?
4. Score all new leads (instantly)
5. Return ranked list: Top 10 leads to call today

Implementation: from nvidia_sdm import TabICLv2

Load leads

leads = load_csv("leads_this_week.csv")

Load examples (high-value leads from history)

high_value = load_csv("closed_deals_2025.csv")

Predict

model = TabICLv2() scores = model.predict( examples=high_value, new_data=leads )

Rank

top_10 = leads[scores.argsort()[-10:]]

Agent sends to Slack

agent.send_message( "Top 10 leads to call today:", top_10 )

Result:

• Manual work: 3 hours → 0 minutes
• Accuracy: 70% (manual) → 92% (model)
• Scalability: 10 leads/day → 1000 leads/day

Use case 2: Customer churn prediction (support automation)

Problem (currently):

Support team: "Which customers are at risk of leaving?"

Signals scattered:

• Support tickets (increasing frequency?)
• Product usage (declining?)
• Billing issues (late payments?)
• Feature requests (frustrated?)

Old way:

• Manual review of each customer (expensive)
• Miss at-risk customers (reactive, not proactive)
• Can't scale

Solution (with SDM + agent):

Agent workflow:

1. Load customer behavior data (support tickets, usage stats, billing, feature requests)
2. Show examples of "churned customers" (why did they leave?)
3. Model learns: What patterns lead to churn?
4. Score all active customers (who's likely to churn?)
5. Alert support: "These 15 customers need attention"
6. Agent auto-escalates to human if score > 80%

Implementation: from nvidia_sdm import KumoTabular

Load customer data

customers = load_csv("customer_behavior.csv")

Columns: support_tickets_30d, usage_drop_pct,

late_payments_count, feature_requests,

last_login_days_ago

Load churned customers (examples)

churned = load_csv("churned_2024_2025.csv")

Predict

model = KumoTabular() churn_risk = model.predict( examples=churned, new_data=customers )

Alert

at_risk = customers[churn_risk > 0.7] agent.escalate_to_support( f"Churn risk detected: {len(at_risk)} customers", at_risk )

Result:

• Reactive support → Proactive support
• Miss churn signals → Catch 80% of churners early
• Churn rate: 5% → 3% (saves customer lifetime value)

Use case 3: Deal prediction (sales forecasting)

Problem (currently):

CFO needs: "What's our revenue next quarter?" Sales VP answers: "Best guess: $2M-$3M" CFO: "That's not good enough. Be more precise." Sales VP: "I'll call each rep and aggregate..." (6 hours later: Still uncertain)

Solution (with SDM + agent):

Agent workflow:

1. Load deal pipeline (stage, amount, customer type, age, etc)
2. Show historical deals (which ones closed? which didn't?)
3. Model learns: What signals predict deal closure?
4. Score all open deals (probability of closing)
5. Forecast revenue (sum of probabilities × deal size)
6. Return: "82% confidence: $2.3M next quarter"

Implementation: from nvidia_sdm import TabICLv2

Load open deals

deals = load_csv("pipeline_this_quarter.csv")

Columns: deal_size, stage, customer_type, age_days,

engagement_score, decision_made, contract_signed

Load historical (closed vs lost)

history = load_csv("deals_closed_2024.csv")

Predict

model = TabICLv2() closure_prob = model.predict( examples=history, new_data=deals )

Forecast

revenue_forecast = (deals['amount'] * closure_prob).sum() confidence = closure_prob.std() # Low std = high confidence

Report

agent.send_to_cfo( f"Q4 Revenue Forecast: ${revenue_forecast:,.0f}", f"Confidence: {confidence:.1%}", deals[closure_prob > 0.5] # Show likely-to-close deals )

Result:

• Guessing → Data-driven forecasting
• Accuracy: 50-60% → 85-90%
• Time: 6 hours → 1 minute
• Scalability: 20 deals → 2000 deals

---

Technical implementation (how to add to your agent)

Installation (5 minutes)

bash

Install NVIDIA SDM library

pip install nvidia-sdm

Install dependencies

pip install pandas numpy torch

Optional: GPU acceleration (faster)

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

Basic example (10 minutes)

python from nvidia_sdm import TabICLv2 import pandas as pd

1. Load your data

df = pd.read_csv("your_data.csv")

2. Load model

model = TabICLv2()

3. Show examples (what you want to predict)

examples = df.head(50) # First 50 rows (labeled)

4. Predict on new data

new_data = df.tail(100) # Last 100 rows (unlabeled) predictions = model.predict( examples=examples, new_data=new_data )

5. Use predictions

for idx, prob in enumerate(predictions): print(f"Row {idx}: Probability = {prob:.2%}")

Agent integration (30 minutes)

python from nvidia_sdm import TabICLv2, KumoRelational from anthropic import Anthropic import pandas as pd

class AgentWithSDM: def init(self): self.client = Anthropic() self.model = TabICLv2() # or KumoRelational() for databases self.data = None self.examples = None

def load_data(self, csv_path: str):
    """Load your spreadsheet"""
    self.data = pd.read_csv(csv_path)
    print(f"Loaded {len(self.data)} rows")

def set_examples(self, labeled_csv_path: str):
    """Load examples (labeled data)"""
    self.examples = pd.read_csv(labeled_csv_path)
    print(f"Loaded {len(self.examples)} labeled examples")

def predict(self, new_data: pd.DataFrame):
    """Make predictions using NVIDIA SDM"""
    return self.model.predict(
        examples=self.examples,
        new_data=new_data
    )

def chat_with_data(self, user_message: str):
    """Agent processes user query with data"""
    # User: "Which customers should we call first?"
    
    # Step 1: Claude understands intent
    response = self.client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": user_message}
        ],
        system="You are a data analyst. When asked about data, use NVIDIA SDM to make predictions."
    )
    
    # Step 2: Parse Claude's response to identify task
    # (if "predict", "score", "rank", etc.)
    
    # Step 3: Run NVIDIA SDM prediction
    predictions = self.predict(self.data)
    
    # Step 4: Format and return
    top_10 = self.data.nlargest(10, predictions)
    return f"Top 10 customers to contact:\n{top_10.to_string()}"

Usage

agent = AgentWithSDM() agent.load_data("customers.csv") agent.set_examples("high_value_customers.csv") result = agent.chat_with_data("Which leads should I contact today?") print(result)

---

Your competitive advantage (why implement now)

Speed to value

Old way: Week 1: Collect requirements Week 2-3: Data preparation Week 3-4: Model training Week 4-5: Integration Week 6: Testing Time: 6 weeks Cost: $10k-50k

SDM way: Day 1: Install library (5 min) Day 1: Load data (5 min) Day 1: Make first prediction (1 min) Day 2-3: Integrate with agent Day 4: Deploy Time: 4 days Cost: $0-100 (inference only)

Accuracy without data

Traditional ML: Need: 1000+ labeled examples Training time: Days-weeks Accuracy ramp: 60% → 75% → 85% (as you collect more data)

SDM (in-context learning): Need: 10-50 examples Training time: Instant Accuracy: 85% immediately (no ramp)

Privacy + control

Cloud APIs:

• Upload data to third party (privacy risk)
• Dependent on their uptime
• Limited customization
• Expensive at scale

SDM:

• Run on your servers (data stays private)
• No external dependency
• Customizable (your own examples)
• Cheap at scale (one-time cost)

---

Your timeline (what to do)

Week 1: POC

☐ Download NVIDIA SDM ☐ Load your busiest spreadsheet ☐ Create "examples" (10-50 rows you know) ☐ Make predictions (< 5 min setup) ☐ Compare accuracy to current method

Question: Does it work as well (or better)? If yes → Move to integration

Week 2: Integration

☐ Connect SDM to your agent ☐ Create agent tool: "Predict from data" ☐ Test with real queries ☐ Measure latency (should be <1s) ☐ Compare results to manual (should be better)

Question: Does agent use it correctly? If yes → Deploy

Week 3: Deploy

☐ Deploy to production (start with 10% of traffic) ☐ Monitor accuracy (should match POC) ☐ Monitor latency (should be <1s) ☐ Monitor cost (should be near-zero) ☐ Gradually increase to 100% traffic

Question: Does production work as expected? If yes → Celebrate (you just automated data analysis)

---

Conclusion: Your agent just learned to read spreadsheets

What changed:

Before NVIDIA SDM: Agent: "I can chat, but I can't understand your spreadsheet." You: "Then agent is limited. Only works on text problems."

After NVIDIA SDM: Agent: "I can read your spreadsheet, understand patterns, make predictions." You: "Now agent is complete. Works on everything (text + data)."

What you can build (immediately):

1. Lead scoring (sales automation)

   • Input: Spreadsheet of leads
   • Output: Ranked list (who to call first)
   • ROI: 50% better sales productivity

2. Churn prediction (support automation)

   • Input: Customer behavior data
   • Output: At-risk customers
   • ROI: Prevent churn (save customer LTV)

3. Deal forecasting (finance automation)

   • Input: Deal pipeline
   • Output: Revenue forecast
   • ROI: Better planning accuracy

4. Pricing optimization (revenue automation)

   • Input: Customer data + purchase history
   • Output: Optimal price per customer
   • ROI: 5-10% revenue increase

5. Fraud detection (compliance automation)

   • Input: Transaction data
   • Output: Fraud risk score
   • ROI: Prevent fraud losses

Bottom line:

You now have a tool to make your agent understand business data. No training needed. No waiting for ML engineers. No privacy concerns.

Implementation time: 1 week Cost: Minimal Value: Massive (data-driven decisions at scale)

Why wait? Start today.

→ OpenClaw: Structured Data Models, NVIDIA SDM, zero-training predictions, tabular data automation, agent data analysis, business intelligence automation, in-context learning

Seu agent acaba de aprender SQL 📊