@n8n/workflow-sdk 0.9.0 → 0.10.0

package/dist/prompts/best-practices/guides/chatbot.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatbotBestPractices = void 0;
+const types_1 = require("../types");
+class ChatbotBestPractices {
+    constructor() {
+        this.technique = types_1.WorkflowTechnique.CHATBOT;
+        this.version = '1.0.0';
+        this.documentation = `# Best Practices: Chatbot Workflows
+
+## Workflow Design
+
+Break chatbot logic into manageable steps and use error handling nodes (IF, Switch) with fallback mechanisms to manage unexpected inputs.
+
+Most chatbots run through external platforms like Slack, Telegram, or WhatsApp rather than through the n8n chat interface - if the user requests a service like this don't use the built in chat interface nodes. But, the n8n chat node is easier to get started with tests. If the user mentions chatting but does not mention a service then use the built in n8n chat node.
+
+CRITICAL: The user may ask to be able to chat to a workflow as well as trigger it via some other method, for example scheduling information gathering but also being able to chat with the agent - in scenarios like this the two separate workflows MUST be connected through shared memory, vector stores, data storage, or direct connections.
+
+Example pattern:
+- Schedule Trigger → News Gathering Agent → [memory node via ai_memory]
+- Chat Trigger → Chatbot Agent → [SAME memory node via ai_memory]
+- Result: Both agents share conversation/context history, enabling the chatbot to discuss gathered news
+
+For the chatbot always use the same chat node type as used for response. If Telegram has been requested trigger the chatbot via telegram AND
+respond via telegram - do not mix chatbot interfaces.
+
+## Context & Memory Management
+
+Always utilise memory in chatbot agent nodes - providing context gives you full conversation history and more control over context.
+Memory nodes enable the bot to handle follow-up questions by maintaining short-term conversation history.
+
+Include information with the user prompt such as timestamp, user ID, or session metadata. This enriches context without relying solely on memory and user prompt.
+
+If there are other agents involved in the workflow you should share memory between the chatbot and those other agents where it makes sense.
+Connect the same memory node to multiple agents to enable data sharing and context continuity.
+
+## Context Engineering & AI Agent Output
+
+It can be beneficial to respond to the user as a tool of the chatbot agent rather than using the agent output - this allows the agent to loop/carry out multiple responses if necessary.
+This will require adding a note to the system prompt for the agent to tell it to use the tool to respond to the user.
+
+## Message Attribution
+
+n8n chatbots often attach the attribution "n8n workflow" to messages by default - you must disable this setting which will
+often be called "Append n8n Attribution" for nodes that support it, add this setting and set it to false.
+
+## Recommended Nodes
+
+### Chat Trigger (@n8n/n8n-nodes-langchain.chatTrigger)
+
+Purpose: Entry point for user messages in n8n-hosted chat interfaces
+
+Pitfalls:
+
+- Most production chatbots use external platforms (Slack, Telegram) rather than n8n's chat interface
+
+### AI Agent (@n8n/n8n-nodes-langchain.agent)
+
+Purpose: Orchestrates logic, tool use, and LLM calls for intelligent responses.
+
+Unless user asks for a node by name, always use the AI Agent node over provider-specific nodes (like OpenAI, Google Gemini) or use-case-specific AI nodes (like Message a model) for chatbot workflows. The AI Agent node provides better orchestration, tool integration, and memory management capabilities essential for conversational interfaces.
+For example, for "create a chatbot using OpenAI", implement: AI Agent -- OpenAI Chat Model.
+
+### Chat Model Nodes
+
+- OpenAI Chat Model (@n8n/n8n-nodes-langchain.lmChatOpenAi)
+- Google Gemini Chat Model (@n8n/n8n-nodes-langchain.lmChatGoogleGemini)
+- xAI Grok Chat Model (@n8n/n8n-nodes-langchain.lmChatXAiGrok)
+- DeepSeek Chat Model (@n8n/n8n-nodes-langchain.lmChatDeepSeek)
+
+Purpose: Connect to LLMs for natural, context-aware responses
+
+### Simple Memory (@n8n/n8n-nodes-langchain.memoryBufferWindow)
+
+Purpose: Maintains short-term conversation history for context continuity
+
+### HTTP Request (n8n-nodes-base.httpRequest)
+
+Purpose: Fetches external data to enrich chatbot responses with real-time or organizational information
+
+### Database Nodes & Google Sheets
+
+- Data Table (n8n-nodes-base.dataTable)
+- Postgres (n8n-nodes-base.postgres)
+- MySQL (n8n-nodes-base.mySql)
+- MongoDB (n8n-nodes-base.mongoDb)
+- Google Sheets (n8n-nodes-base.googleSheets)
+
+Purpose: Store conversation logs, retrieve structured data, or maintain user preferences
+
+### IF / Switch
+
+- If (n8n-nodes-base.if)
+- Switch (n8n-nodes-base.switch)
+
+Purpose: Conditional logic and error handling for routing messages or managing conversation state
+
+### Integration Nodes
+
+- Slack (n8n-nodes-base.slack)
+- Telegram (n8n-nodes-base.telegram)
+- WhatsApp Business Cloud (n8n-nodes-base.whatsApp)
+- Discord (n8n-nodes-base.discord)
+
+Purpose: Multi-channel support for deploying chatbots on popular messaging platforms
+
+## Common Pitfalls to Avoid
+
+### Leaving Chatbot Disconnected
+
+When a workflow has multiple triggers (e.g., scheduled data collection + chatbot interaction), the chatbot MUST have access to the data
+generated by the workflow. Connect the chatbot through shared memory, vector stores, data storage, or direct data flow connections.
+`;
+    }
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.ChatbotBestPractices = ChatbotBestPractices;
+//# sourceMappingURL=chatbot.js.map

package/dist/prompts/best-practices/guides/chatbot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatbot.js","sourceRoot":"","sources":["../../../../src/prompts/best-practices/guides/chatbot.ts"],"names":[],"mappings":";;;AACA,oCAA6C;AAE7C,MAAa,oBAAoB;IAAjC;QACU,cAAS,GAAG,yBAAiB,CAAC,OAAO,CAAC;QACtC,YAAO,GAAG,OAAO,CAAC;QAEV,kBAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwGjC,CAAC;IAKF,CAAC;IAHA,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AAjHD,oDAiHC"}

package/dist/prompts/best-practices/guides/content-generation.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../types';
+export declare class ContentGenerationBestPractices implements BestPracticesDocument {
+    readonly technique: "content_generation";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/prompts/best-practices/guides/content-generation.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentGenerationBestPractices = void 0;
+const types_1 = require("../types");
+class ContentGenerationBestPractices {
+    constructor() {
+        this.technique = types_1.WorkflowTechnique.CONTENT_GENERATION;
+        this.version = '1.0.0';
+        this.documentation = `# Best Practices: Content Generation Workflows
+
+## Workflow Design
+
+Break complex tasks into sequential steps (e.g., generate text, create image, compose video) for modularity and easier troubleshooting.
+
+## Node Selection Guidelines
+
+Always prefer built-in n8n nodes over HTTP Request nodes when a dedicated node exists for the service or API you need to integrate with. Built-in nodes provide:
+- Pre-configured authentication handling
+- Optimized data structures and field mappings
+- Better error handling and user experience
+- Simplified setup without manual API configuration
+
+Only use HTTP Request nodes when no built-in node exists for the service, or when you need to access an API endpoint not covered by the built-in node's operations.
+
+## Multi-Modal Content Generation - MANDATORY
+
+When the user's request involves specific generative AI models or media-focused platforms, the workflow MUST include the appropriate media generation node from a
+provider-specific node. The finished workflow MUST contain the relevant video, audio, or image generation capability.
+
+Prompts that require multi-modal generation nodes:
+
+Video Generation:
+- Model mentions: Sora, Nano Banana, Veo, Runway, Pika
+- Platform mentions: YouTube content, TikTok videos, Instagram Reels, video ads, short-form video
+- Task mentions: generate video, create video, video from text, animate
+
+Image Generation:
+- Model mentions: DALL-E, Midjourney, Stable Diffusion, Imagen
+- Platform mentions: thumbnails, social media graphics, product images, marketing visuals
+- Task mentions: generate image, create artwork, design graphic, visualize
+
+Audio Generation:
+- Model mentions: ElevenLabs, text-to-speech, TTS
+- Platform mentions: podcast audio, voiceovers, narration, audio content
+- Task mentions: generate voice, create audio, synthesize speech, clone voice
+
+If anything like the examples above are mentioned in the prompt, include the appropriate
+provider node (OpenAI for DALL-E/Sora, Google Gemini for Nano Banana/Imagen, etc.)
+with the media generation operation configured.
+
+## Content-Specific Guidance
+
+For text generation, validate and sanitize input/output to avoid malformed data. When generating images, prefer binary data over URLs for uploads to avoid media type errors.
+
+## Recommended Nodes
+
+### OpenAI (@n8n/n8n-nodes-langchain.openAi)
+
+Purpose: GPT-based text generation, DALL-E image generation, text-to-speech (TTS), and audio transcription, SORA for video generation
+
+### xAI Grok Chat Model (@n8n/n8n-nodes-langchain.lmChatXAiGrok)
+
+Purpose: Conversational AI and text generation
+
+### Google Gemini Chat Model (@n8n/n8n-nodes-langchain.lmChatGoogleGemini)
+
+Purpose: Image analysis and generation, video generation from text prompts using nano banana, multimodal content creation
+
+### ElevenLabs
+
+Purpose: Natural-sounding AI voice generation
+
+Note: Use HTTP Request node or a community node to integrate with ElevenLabs API
+
+### HTTP Request (n8n-nodes-base.httpRequest)
+
+Purpose: Integrating with other LLM and content generation APIs (e.g., Jasper, Writesonic, Anthropic, HuggingFace)
+
+### Edit Image (n8n-nodes-base.editImage)
+
+Purpose: Manipulating images - resize, crop, rotate, and format conversion
+
+Pitfalls:
+
+- Ensure input is valid binary image data
+- Check output format compatibility with downstream nodes
+
+### Markdown (n8n-nodes-base.markdown)
+
+Purpose: Formatting and converting text to HTML or Markdown reports
+
+### Facebook Graph API (n8n-nodes-base.facebookGraphApi)
+
+Purpose: Uploading videos and images to Instagram and Facebook
+
+Pitfalls:
+
+- Use binary data fields rather than URLs for media uploads to prevent "media type" errors
+- Verify page IDs and access tokens have correct permissions
+
+### Wait (n8n-nodes-base.wait)
+
+Purpose: Handling delays in video processing/uploading and respecting API rate limits
+
+## Common Pitfalls to Avoid
+
+Binary Data Handling: For media uploads, use binary fields rather than URLs to prevent "media type" errors, especially with Facebook and Instagram APIs. Download media to binary data first, then upload from binary rather than passing URLs.
+
+Async Processing: For long-running content generation tasks (especially video), implement proper wait/polling mechanisms. Don't assume instant completion - many AI services process requests asynchronously.
+`;
+    }
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.ContentGenerationBestPractices = ContentGenerationBestPractices;
+//# sourceMappingURL=content-generation.js.map

package/dist/prompts/best-practices/guides/content-generation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-generation.js","sourceRoot":"","sources":["../../../../src/prompts/best-practices/guides/content-generation.ts"],"names":[],"mappings":";;;AACA,oCAA6C;AAE7C,MAAa,8BAA8B;IAA3C;QACU,cAAS,GAAG,yBAAiB,CAAC,kBAAkB,CAAC;QACjD,YAAO,GAAG,OAAO,CAAC;QAEV,kBAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqGjC,CAAC;IAKF,CAAC;IAHA,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AA9GD,wEA8GC"}

package/dist/prompts/best-practices/guides/data-analysis.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../types';
+export declare class DataAnalysisBestPractices implements BestPracticesDocument {
+    readonly technique: "data_analysis";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/prompts/best-practices/guides/data-analysis.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataAnalysisBestPractices = void 0;
+const types_1 = require("../types");
+class DataAnalysisBestPractices {
+    constructor() {
+        this.technique = types_1.WorkflowTechnique.DATA_ANALYSIS;
+        this.version = '1.0.0';
+        this.documentation = `# Best Practices: Data Analysis Workflows
+
+## Workflow Design
+
+Structure workflows following the Input → Transform → Output pattern. Use clear node naming (e.g., "Fetch Sales Data", "Calculate Averages", "IF High Variance?") to document the flow.
+
+Start with appropriate triggers:
+- Manual Trigger for on-demand analysis
+- Cron/Schedule Trigger for periodic analysis (daily/weekly reports)
+- Webhook Trigger for event-driven analysis
+
+Break complex workflows into modular sub-workflows using the Execute Workflow node for reusable components like "Outlier Detection" or "Data Preparation".
+
+CRITICAL: For large datasets, use Split In Batches node to process items in chunks (e.g., 100 at a time) to prevent memory issues. Always test with realistic data volumes.
+
+Example pattern:
+- Trigger → HTTP Request (fetch data) → Spreadsheet File (parse CSV) → Set (clean fields) → Filter (remove nulls) → Code (analyze) → HTML (format report) → Email (send results)
+
+## Data Preparation Strategy
+
+1. **Fetch Data**: Use dedicated integration nodes or HTTP Request for APIs. Import cURL commands directly to HTTP node for complex APIs.
+2. **Parse & Convert**: Convert to JSON using Spreadsheet File node for CSV/Excel. Enable "Convert types where required" on condition nodes.
+3. **Clean Data**: Use Set node with "Keep Only Set" enabled to drop unused fields. Filter node for removing null values or focusing on data subsets.
+4. **Merge/Enrich**: Use Merge node by key or index to combine multiple sources. Choose correct merge mode to avoid mismatched items.
+
+## Analysis Implementation
+
+Use Function node (not Function Item) when analysis needs all items as a whole (calculating totals, finding trends). Function Item operates per item only.
+
+For AI-powered analysis, filter irrelevant content first to minimize tokens. Batch data into single prompts when possible.
+
+Always pin data after external calls to test downstream logic without re-fetching. This saves API costs and speeds development.
+
+## Output & Integration
+
+Format results appropriately:
+- HTML/Markdown nodes for reports
+- Set node to prepare specific output fields (totalSales, anomalyCount)
+- Database nodes to store analysis history
+- Webhook Response for API-triggered workflows
+
+Use conditional branches (IF nodes) for post-analysis actions:
+- Create tasks if anomalies detected
+- Send alerts for critical thresholds
+- Avoid infinite loops by using proper conditions
+
+## Recommended Nodes
+
+### HTTP Request (n8n-nodes-base.httpRequest)
+
+**Purpose**: Fetch datasets from URLs or APIs
+
+**Use Cases**:
+- Pull data from REST APIs for analysis
+- Fetch CSV/JSON files from URLs
+- Query external data sources
+
+**Best Practices**:
+- Import cURL commands for complex requests
+- Use authentication credentials properly
+- Handle pagination for large datasets
+
+### Spreadsheet File (n8n-nodes-base.spreadsheetFile)
+
+**Purpose**: Parse CSV/Excel files into JSON items for processing
+
+**Use Cases**:
+- Import CSV data from file uploads
+- Process Excel spreadsheets
+- Convert tabular data to JSON
+
+**Best Practices**:
+- Specify correct file format
+- Handle header rows properly
+- Test with various file encodings
+
+### Set / Edit Fields (n8n-nodes-base.set)
+
+**Purpose**: Clean data, select relevant fields, rename columns, convert data types
+
+**Key Setting**: "Keep Only Set" - drops all fields not explicitly defined
+
+**Use Cases**:
+- Remove unused columns to reduce data size
+- Rename fields to standardized names
+- Convert data types (string to number)
+- Add calculated fields
+
+**Best Practices**:
+- Enable "Keep Only Set" to drop unused data
+- Always verify output structure
+- Use expressions for calculated fields
+
+### Filter (n8n-nodes-base.filter)
+
+**Purpose**: Remove unwanted items based on conditions
+
+**Use Cases**:
+- Remove null values
+- Filter outliers before analysis
+- Focus on specific data subsets
+
+**Best Practices**:
+- Filter early to reduce processing load
+- Use multiple conditions when needed
+- Document filter logic clearly
+
+### IF (n8n-nodes-base.if)
+
+**Purpose**: Branch workflow based on analysis results
+
+**Use Cases**:
+- Route anomalies vs normal data
+- Trigger alerts for threshold breaches
+- Create conditional outputs
+
+**Best Practices**:
+- Enable "Convert types where required" for comparisons
+- Use clear condition names
+- Handle both true and false branches
+
+### Code / Function (n8n-nodes-base.function)
+
+**Purpose**: Custom JavaScript for calculations, statistics, anomaly detection
+
+**Use Cases**:
+- Calculate statistical measures (mean, median, std dev)
+- Detect outliers and anomalies
+- Perform complex transformations
+- Implement custom algorithms
+
+**Best Practices**:
+- Use Function node (not Function Item) for whole-dataset operations
+- Return proper data structure: \`return items\`
+- Add comments to explain logic
+- Test with edge cases
+
+**Note**: Consider using the newer Code node (n8n-nodes-base.code) as Function node is deprecated.
+
+### Aggregate (n8n-nodes-base.aggregate)
+
+**Purpose**: Group items, gather values into arrays, count occurrences by category
+
+**Use Cases**:
+- Group sales by region
+- Count items by category
+- Calculate sums and averages per group
+
+**Best Practices**:
+- Choose appropriate aggregation function
+- Use grouping keys effectively
+- Simplifies statistical calculations
+
+### Split In Batches (n8n-nodes-base.splitInBatches)
+
+**Purpose**: Process large datasets in chunks to prevent memory overload
+
+**Use Cases**:
+- Handle datasets with 1000+ items
+- Process API results in batches
+- Prevent workflow timeouts
+
+**Best Practices**:
+- Set appropriate batch size (e.g., 100 items)
+- Test with realistic data volumes
+- Use loop logic properly
+
+### Merge (n8n-nodes-base.merge)
+
+**Purpose**: Combine data from multiple sources by key/index
+
+**Modes**:
+- Merge by Key: Join data like database operations
+- Merge by Index: Combine parallel data streams
+- Wait mode: Synchronize parallel branches
+
+**Use Cases**:
+- Join customer data with transaction data
+- Combine multiple API responses
+- Enrich data from multiple sources
+
+**Best Practices**:
+- Choose correct merge mode
+- Ensure matching keys exist
+- Handle missing data gracefully
+
+### Database Nodes
+
+**MySQL** (n8n-nodes-base.mySql):
+- Purpose: Query MySQL databases for analysis data
+- Use cases: Fetch historical data, store results
+
+**Postgres** (n8n-nodes-base.postgres):
+- Purpose: Query PostgreSQL databases
+- Use cases: Complex analytical queries, time-series data
+
+**MongoDB** (n8n-nodes-base.mongoDb):
+- Purpose: Query NoSQL document databases
+- Use cases: Unstructured data analysis, JSON documents
+
+**Best Practices**:
+- Use parameterized queries for security
+- Query source data efficiently with proper indexes
+- Store analysis results for historical tracking
+- Use appropriate data types
+
+### Google Sheets (n8n-nodes-base.googleSheets)
+
+**Purpose**: Read/write spreadsheet data
+
+**Use Cases**:
+- Import data for analysis
+- Append summary statistics
+- Build analysis logs
+- Share results with stakeholders
+
+**Best Practices**:
+- Use range specifications efficiently
+- Handle large sheets with batching
+- Consider API rate limits
+
+### AI Agent (@n8n/n8n-nodes-langchain.agent)
+
+**Purpose**: Leverage AI for text analysis, sentiment detection, complex pattern recognition
+
+**Use Cases**:
+- Sentiment analysis of customer feedback
+- Text classification
+- Extract insights from unstructured data
+- Natural language processing
+
+**Best Practices**:
+- Filter irrelevant content first to minimize tokens
+- Batch data into single prompts when possible
+- Use structured output for consistency
+- Consider API costs and latency
+
+### HTML (n8n-nodes-base.html)
+
+**Purpose**: Generate formatted reports with tables and styling
+
+**Use Cases**:
+- Create analysis reports
+- Build dashboards
+- Color-code data quality scores
+- Format tables with results
+
+**Best Practices**:
+- Use templates for consistent formatting
+- Include visualizations where helpful
+- Make reports mobile-friendly
+
+### Email (n8n-nodes-base.emailSend)
+
+**Purpose**: Send analysis reports to stakeholders automatically
+
+**Use Cases**:
+- Scheduled report delivery
+- Alert notifications
+- Share findings with teams
+
+**Best Practices**:
+- Use clear subject lines
+- Include summary in email body
+- Attach detailed reports when needed
+- Schedule appropriately
+
+## Common Pitfalls to Avoid
+
+### Data Type Mismatches
+
+**Problem**: JSON data types matter. Comparing string vs number yields incorrect results. The comparison "5" > "10" is lexicographically true (wrong for numbers).
+
+**Solution**:
+- Always convert data types before comparisons
+- Use Number() or parseInt() for numeric operations
+- Enable "Convert types where required" on IF nodes
+- Validate data types early in workflow
+- Use proper type casting in Code nodes
+
+### Memory Issues with Large Datasets
+
+**Problem**: Processing thousands of items at once can crash workflows or timeout.
+
+**Solution**:
+- Use Split In Batches node for datasets over 100 items
+- Set appropriate batch sizes (50-100 items)
+- Test with realistic data volumes during development
+- Monitor memory usage in production
+- Consider sub-workflows for complex processing
+
+### Not Pinning Data During Development
+
+**Problem**: Re-fetching data from APIs repeatedly wastes time and costs money during development.
+
+**Solution**:
+- Always pin data after external calls
+- Test downstream logic without re-fetching
+- Saves API costs and speeds development
+- Use manual triggers to control execution
+
+### Incorrect Aggregation Logic
+
+**Problem**: Using Function Item instead of Function node for whole-dataset calculations.
+
+**Solution**:
+- Use Function node (not Function Item) for totals, averages, trends
+- Function Item operates per item only
+- Understand the difference between item-level and dataset-level operations
+- Use Aggregate node for common operations
+
+### Missing Data Cleaning
+
+**Problem**: Null values, inconsistent formats, or outliers skew analysis results.
+
+**Solution**:
+- Use Filter node to remove null values
+- Standardize data formats early
+- Handle missing data explicitly
+- Use Set node to clean and normalize fields
+- Document data quality assumptions
+
+### Poor Error Handling
+
+**Problem**: Failed API calls or data issues break the entire workflow.
+
+**Solution**:
+- Use "Continue on Fail" setting appropriately
+- Add IF nodes to check for empty datasets
+- Implement error logging
+- Use Error Trigger workflows for global handling
+- Validate data quality before analysis
+
+### Hardcoded Values
+
+**Problem**: Thresholds, API endpoints, or configuration values are hardcoded in nodes.
+
+**Solution**:
+- Store configuration in environment variables
+- Use Google Sheets or databases for thresholds
+- Makes workflows reusable and maintainable
+- Enable non-technical users to adjust parameters
+
+### Inefficient Query Patterns
+
+**Problem**: Fetching entire datasets when only summary data is needed.
+
+**Solution**:
+- Use database aggregation functions
+- Filter data at the source
+- Use appropriate indexes
+- Implement pagination for large results
+- Consider pre-aggregated views
+`;
+    }
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.DataAnalysisBestPractices = DataAnalysisBestPractices;
+//# sourceMappingURL=data-analysis.js.map

package/dist/prompts/best-practices/guides/data-analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-analysis.js","sourceRoot":"","sources":["../../../../src/prompts/best-practices/guides/data-analysis.ts"],"names":[],"mappings":";;;AACA,oCAA6C;AAE7C,MAAa,yBAAyB;IAAtC;QACU,cAAS,GAAG,yBAAiB,CAAC,aAAa,CAAC;QAC5C,YAAO,GAAG,OAAO,CAAC;QAEV,kBAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiWjC,CAAC;IAKF,CAAC;IAHA,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AA1WD,8DA0WC"}

package/dist/prompts/best-practices/guides/data-extraction.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../types';
+export declare class DataExtractionBestPractices implements BestPracticesDocument {
+    readonly technique: "data_extraction";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}