Datacake AI Nodes
AI-powered data analysis and report generation for IoT applications using OpenAI's Response API.
Overview
The Datacake AI nodes enable you to analyze IoT sensor data, generate reports, and extract insights using advanced AI models from OpenAI. Perfect for:
📊 Automated data analysis and anomaly detection
📝 Report generation (Markdown, HTML, PDF-ready)
💡 Predictive maintenance insights
📈 Time series analysis and trend detection
🔍 Root cause analysis
💻 Python code execution for calculations and visualizations
Configuration
Datacake AI Config
Configuration node for storing OpenAI API credentials securely.
Settings
Name - Optional descriptive name for this configuration
OpenAI API Key - Your OpenAI API key (starts with
sk-...
)
How to Get Your API Key
Visit OpenAI Platform
Sign in or create an account
Click "Create new secret key"
Copy the key (starts with
sk-...
)Store it securely in the Datacake AI Config node
⚠️ Important: Keep your API key secure. Never share it or commit it to version control.
Datacake AI Node
Execute AI-powered analysis and report generation using OpenAI's models.
Configuration
Model Selection
Choose the AI model based on your needs:
gpt-5
Slower
Highest
$1.25 in / $10.00 out
Complex analysis, research
gpt-5-mini
Medium
High
$0.25 in / $2.00 out
Recommended for most use cases
gpt-5-nano
Fastest
Good
$0.05 in / $0.40 out
Simple tasks, quick responses
💡 The UI shows real-time cost estimates based on your max token setting.
Prompt Configuration
Prompt Source:
From msg.prompt - Dynamic prompts from incoming messages (flexible)
From Configuration - Static prompt configured in the node (reusable)
Include msg.payload:
When enabled, automatically includes incoming data in the prompt
Perfect for CSV, JSON, or text data analysis
Data type is automatically detected and formatted
Tools
Code Interpreter:
✅ Enable for any data analysis tasks
Executes Python code for calculations, statistics, and visualizations
Can read CSV/JSON data, perform complex calculations, generate charts
Essential for accurate numerical analysis
Web Search:
🌐 Enable for real-time information retrieval
Access up-to-date information from the web
Useful for market research, trend analysis, fact-checking
Configure search context size (low/medium/high)
Advanced Options
Max Output Tokens:
Controls maximum response length
Higher values = longer responses but higher cost
Default: 16,000 tokens (~12,000 words)
Typical reports use 2,000-8,000 tokens
Input Properties
msg.prompt
string
No*
The AI prompt/instruction (*required when using "From msg.prompt" mode)
msg.payload
any
No
Data to analyze (CSV, JSON, text) when "Include msg.payload" is enabled
msg.previousResponseId
string
No
Previous response ID for conversational context
msg.model
string
No
Override the configured model (e.g., "gpt-5-mini")
Output Properties
msg.payload
string
Clean AI response text (user-friendly, ready to use)
msg.responseId
string
Response ID for follow-up questions with context
msg.openai
object
Detailed metadata about the request
Output Metadata (msg.openai
)
{
model: "gpt-5-mini", // Model used
promptSource: "msg", // Where prompt came from
toolsUsed: ["code_interpreter"], // Tools enabled
hadContext: false, // Whether context was used
responseId: "resp_abc123...", // Response ID
usage: { // Token usage
input_tokens: 1234,
cached_tokens: 0,
output_tokens: 567,
total_tokens: 1801
},
cost: { // Cost breakdown in USD
inputTokens: 1234,
cachedTokens: 0,
outputTokens: 567,
totalTokens: 1801,
inputCost: 0.000308, // $0.000308
cachedCost: 0.000000,
outputCost: 0.001134, // $0.001134
totalCost: 0.001442, // $0.001442
currency: "USD"
},
fullResponse: { /* Complete raw API response */ }
}
Status Display
The node shows real-time status in the editor:
🟢 Success ($0.00142) - Request completed with cost
🔵 Processing... - Request in progress
🔴 Error - Request failed with error message
Use Cases & Examples
1. IoT Sensor Data Analysis
Analyze CSV sensor data and identify anomalies, trends, and patterns.
Flow:
[File Read: sensor-data.csv]
↓
[Datacake AI]
Model: gpt-5-mini
Code Interpreter: ✅ Enabled
Include msg.payload: ✅ Yes
Prompt: "Analyze this IoT sensor data and create a report including:
1. Data overview and statistics
2. Temperature and humidity trends
3. Anomaly detection
4. Correlations between sensors
5. Recommendations"
↓
[Debug/File Write]
Example Output:
# IoT Sensor Data Analysis Report
## Executive Summary
- Analyzed 10,000 data points from 15 sensors over 7 days
- Average temperature: 22.3°C (range: 18.5°C to 28.1°C)
- Average humidity: 55.2% (range: 42% to 78%)
## Key Findings
1. **Temperature Spike Detected**: Sensor #7 showed abnormal reading of 35°C on 2025-02-15
2. **Strong Correlation**: Temperature and humidity show inverse correlation (r=-0.82)
3. **Daily Pattern**: Temperature peaks around 2 PM daily
## Recommendations
1. Investigate Sensor #7 for potential malfunction
2. Consider HVAC optimization based on temperature patterns
3. Monitor humidity levels in zones with readings >70%
2. Automated Markdown Report Generation
Generate professional reports with actual calculations from data.
Flow:
[Datacake GraphQL History]
↓
[Function: Prepare data]
msg.payload = msg.payload.data.TEMPERATURE; // Time series data
msg.prompt = `Create a professional markdown report analyzing temperature data.
Include:
- Statistical summary (mean, median, std dev)
- Trend analysis with real calculations
- Anomaly detection
- Hourly/daily patterns
Output ONLY the markdown report (no preamble).`;
return msg;
↓
[Datacake AI]
Model: gpt-5-mini
Code Interpreter: ✅ Enabled
Include msg.payload: ✅ Yes
Prompt Source: From msg.prompt
↓
[File Write: temperature-report.md]
Tips for Report Generation:
Always enable Code Interpreter for accurate calculations
Request "Output ONLY the markdown" to get clean results
Use specific format requirements (tables, sections, etc.)
Request charts/graphs descriptions for visualization needs
3. Conversational Data Analysis
Have a multi-turn conversation about your data with context.
First Message:
[Function: Initial prompt]
msg.payload = deviceHistoryCSV;
msg.prompt = "Analyze this device performance data and identify the top 3 issues";
return msg;
↓
[Datacake AI]
↓
[Function: Store response ID]
flow.set('lastResponseId', msg.responseId);
return msg;
↓
[Debug: View initial analysis]
Follow-up Message:
[Function: Follow-up question]
msg.prompt = "For issue #1, what are your detailed recommendations and cost estimates?";
msg.previousResponseId = flow.get('lastResponseId');
return msg;
↓
[Datacake AI]
↓
[Debug: View detailed recommendations]
Benefits:
Maintain context across multiple questions
Drill down into specific findings
Build on previous analysis
More efficient token usage (context is cached)
4. Predictive Maintenance Analysis
Analyze device trends and predict potential failures.
Flow:
[Datacake GraphQL History]
Device: Industrial Pump
Time Range: Last 30 days
Fields: TEMPERATURE, VIBRATION, PRESSURE
↓
[Function: Prepare maintenance prompt]
msg.prompt = `Analyze this industrial pump data for predictive maintenance:
1. Identify degradation patterns
2. Detect anomalies in temperature, vibration, and pressure
3. Predict potential failure points
4. Calculate remaining useful life estimate
5. Recommend maintenance schedule
Provide actionable insights with confidence levels.`;
return msg;
↓
[Datacake AI]
Model: gpt-5-mini
Code Interpreter: ✅ Enabled
↓
[Function: Parse recommendations]
↓
[Switch: Check urgency level]
↓
[Email/SMS Alert if urgent]
5. Fleet Health Summary with AI Insights
Combine fleet data with AI analysis for executive reports.
Flow:
[Datacake GraphQL Fleet Health]
↓
[Function: Prepare fleet summary]
msg.fleetData = msg.payload; // Store fleet data
msg.prompt = `Analyze this IoT fleet health data and create an executive summary:
${JSON.stringify(msg.payload, null, 2)}
Include:
1. Overall fleet health assessment (grade A-F)
2. Key concerns and their severity
3. Devices requiring immediate attention
4. 30-day trend analysis
5. Cost impact of identified issues
6. Priority action items
Keep it concise for executives (max 500 words).`;
return msg;
↓
[Datacake AI]
Model: gpt-5-mini
↓
[Email to Management]
6. Energy Consumption Optimization
Analyze consumption patterns and suggest optimizations.
Flow:
[Datacake GraphQL Consumption]
Include Monthly Breakdown: ✅ Yes
↓
[Function: Prepare optimization prompt]
msg.prompt = `Analyze this energy consumption data and provide optimization recommendations:
1. Identify consumption patterns and anomalies
2. Compare actual vs expected consumption
3. Detect potential waste or inefficiencies
4. Calculate potential savings
5. Recommend specific actions with ROI estimates
Focus on actionable insights.`;
return msg;
↓
[Datacake AI]
Model: gpt-5-mini
Code Interpreter: ✅ Enabled
↓
[Function: Extract savings opportunities]
↓
[Dashboard + Email Report]
7. Real-time Market Research
Combine IoT data with web research for competitive analysis.
Flow:
[Datacake GraphQL Product Stats]
↓
[Function: Prepare research prompt]
msg.prompt = `Our IoT device fleet shows these statistics:
${JSON.stringify(msg.payload)}
Research and compare:
1. Latest IoT industry benchmarks for 2025
2. Our performance vs competitors
3. Emerging trends that could affect our devices
4. Recommended improvements based on market leaders
Provide sources for key claims.`;
return msg;
↓
[Datacake AI]
Model: gpt-5-mini
Web Search: ✅ Enabled
Search Context: High
↓
[Debug/Report]
8. Anomaly Detection with Root Cause Analysis
Detect anomalies and automatically investigate root causes.
Flow:
[Datacake GraphQL Device]
↓
[Function: Detect anomaly]
if (msg.payload.TEMPERATURE > threshold) {
// Anomaly detected - get history
msg.deviceId = msg.payload.id;
return msg;
}
↓
[Datacake GraphQL History]
Time Range: Last 24 hours
Fields: All sensor fields
↓
[Function: Root cause prompt]
msg.prompt = `ANOMALY DETECTED: Temperature reading of ${msg.payload.currentTemp}°C (threshold: ${threshold}°C)
Historical data:
${JSON.stringify(msg.payload.data)}
Perform root cause analysis:
1. When did the anomaly start?
2. What other parameters changed around the same time?
3. What are the most likely causes?
4. What should be checked first?
5. Is this a sensor issue or real environmental change?`;
return msg;
↓
[Datacake AI]
Model: gpt-5-mini
Code Interpreter: ✅ Enabled
↓
[Email Alert with Analysis]
Advanced Features
Conversational Context
Use msg.previousResponseId
to maintain context across multiple AI interactions:
// First message
msg.prompt = "Analyze this data";
msg.payload = sensorData;
// AI responds with responseId
// Follow-up message (maintains context)
msg.prompt = "Now create a summary table";
msg.previousResponseId = flow.get('previousResponseId');
// AI remembers the previous analysis
Benefits:
More efficient (context tokens are cached and cheaper)
AI understands references to previous analysis
Can build complex analysis step-by-step
Natural conversation flow
Dynamic Model Selection
Override the configured model based on task complexity:
// Use fast model for simple tasks
if (msg.taskType === 'simple') {
msg.model = 'gpt-5-nano';
} else if (msg.taskType === 'complex') {
msg.model = 'gpt-5';
} else {
msg.model = 'gpt-5-mini'; // default
}
Error Handling
Always include error handling for AI nodes:
[Datacake AI]
↓
[Catch Node]
↓
[Function: Log error and notify]
node.error(msg.error);
msg.payload = {
error: true,
message: "AI analysis failed",
details: msg.error
};
return msg;
Cost Management
Understanding Costs
The node automatically calculates costs for every request:
Token Types:
Input tokens: Your prompt + data
Cached tokens: Reused context (90% discount)
Output tokens: AI response
Cost Example:
{
inputTokens: 1234, // 1,234 tokens @ $0.25/1M
cachedTokens: 500, // 500 tokens @ $0.025/1M
outputTokens: 2000, // 2,000 tokens @ $2.00/1M
totalCost: 0.004309 // $0.00431 total
}
Cost Optimization Tips
Choose the right model:
Use gpt-5-nano for simple tasks ($0.40/1M output)
Use gpt-5-mini for most tasks ($2.00/1M output)
Reserve gpt-5 for complex analysis ($10.00/1M output)
Optimize prompts:
Be specific but concise
Avoid sending unnecessary data
Use conversational context to reduce repeated information
Control output length:
Set appropriate Max Output Tokens
Request concise outputs when appropriate
Use bullet points instead of paragraphs
Use context efficiently:
Pass
previousResponseId
for follow-up questionsCached tokens cost 90% less
Build on previous analysis instead of repeating
Monitor usage:
Check
msg.openai.cost
after each requestLog costs to track spending over time
Set up alerts for high-cost requests
View usage at OpenAI Platform
Cost Estimation
The node shows real-time cost estimates in the configuration UI based on your Max Output Tokens setting.
Typical Costs:
Simple analysis: $0.001 - $0.005
Medium report: $0.005 - $0.020
Complex analysis: $0.020 - $0.100
With web search: +$0.005 - $0.020
Best Practices
Prompts
Be specific: "Analyze temperature data and identify anomalies above 30°C" vs "Analyze data"
Request structure: "Provide output as JSON with fields: issue, severity, recommendation"
Set expectations: "Keep response under 200 words" or "Provide detailed analysis"
Include context: Explain what the data represents and what you need
Request calculations: "Calculate actual statistics" when Code Interpreter is enabled
Data Handling
Format data properly: CSV or JSON for structured data
Limit data size: Max ~100KB for optimal performance
Preprocess when needed: Filter/aggregate large datasets before sending
Include headers: CSV headers or JSON keys are important for understanding
Add metadata: Include timestamps, units, device names
Performance
Typical response times:
Simple queries: 5-15 seconds
With Code Interpreter: 10-30 seconds
With Web Search: 15-60 seconds
Complex analysis: 30-90 seconds
Timeout: 5 minutes (600 seconds)
Optimization tips:
Use simpler models for faster responses
Reduce output token limit for quicker replies
Avoid web search when not needed
Error Handling
Always use Catch nodes for AI nodes
Check for rate limits and implement backoff
Validate inputs before sending to AI
Log errors with context for debugging
Provide fallback logic for critical flows
Troubleshooting
Common Issues
"Missing API key" error
Ensure Datacake AI Config node has valid OpenAI API key
Verify key starts with
sk-
Check that key is still valid at OpenAI Platform
"Rate limit exceeded" error
You've exceeded OpenAI API rate limits
Wait and retry
Consider upgrading your OpenAI plan
Implement request throttling in your flows
"Quota exceeded" error
Your OpenAI account has insufficient credits
Add credits at OpenAI Platform
Check your usage limits
Request timeout
Query is too complex or data too large
Try with smaller dataset
Reduce Max Output Tokens
Simplify the prompt
Use a faster model (gpt-5-nano)
Unexpected response format
Check
msg.openai.fullResponse
for debuggingAI response format can vary
Request specific format in prompt
Add response format examples in prompt
Cost higher than expected
Check
msg.openai.cost
to see actual costsLarge data inputs increase input tokens
Long responses increase output tokens
Web search adds cost
Code execution adds compute time
Resources
OpenAI API Documentation: platform.openai.com/docs
Responses API Guide: platform.openai.com/docs/guides/responses
Pricing: openai.com/api/pricing
Usage Dashboard: platform.openai.com/usage
OpenAI Status: status.openai.com
Pricing Reference
gpt-5
$1.25
$0.125
$10.00
gpt-5-mini
$0.25
$0.025
$2.00
gpt-5-nano
$0.05
$0.005
$0.40
Note: Cached tokens (from context reuse) cost 90% less than regular input tokens.
Example Prompts
Data Analysis
Analyze the provided sensor data and create a comprehensive report including:
1. Statistical overview (mean, median, std dev, min, max)
2. Time series trends and patterns
3. Anomaly detection with severity ratings
4. Correlation analysis between parameters
5. Key insights and findings
6. Actionable recommendations
Execute Python code to calculate real statistics.
Report Generation
Create a professional markdown report from this IoT data:
## Required Sections:
- Executive Summary (3-5 bullet points)
- Data Quality Assessment
- Key Metrics and Statistics (in a table)
- Trend Analysis with visualizations description
- Anomalies and Alerts
- Recommendations (prioritized)
- Conclusion
Output ONLY the markdown report with no explanations.
Use actual calculated values, not examples.
Predictive Maintenance
Analyze this industrial equipment sensor data for predictive maintenance:
1. Identify normal operating ranges for each parameter
2. Detect deviations and degradation patterns
3. Assess failure risk (Low/Medium/High)
4. Estimate remaining useful life
5. Recommend maintenance timing and type
6. Prioritize actions by urgency and impact
Provide confidence levels for each prediction.
Optimization Recommendations
Analyze this energy consumption data and provide optimization recommendations:
1. Identify consumption patterns (daily, weekly, seasonal)
2. Detect inefficiencies and waste
3. Compare to industry benchmarks (use web search if enabled)
4. Calculate potential savings for each recommendation
5. Estimate ROI and payback period
6. Prioritize actions by impact and feasibility
Focus on actionable, specific recommendations.
Last updated
Was this helpful?