Skip to content
Heptora Docs

AI Assistants

AI Assistants in Heptora are intelligence-powered tools that transform the way you design, develop, and maintain your automations. From visual process building to intelligent error diagnosis, these assistants accompany you through every stage of your automation lifecycle.

Overview

Section titled “Overview”

Heptora integrates four specialized assistants, each designed to solve specific challenges in automation development:

  1. Process Building Assistant: Visual no-code design
  2. AI Assistant for Advanced Blocks: Automatic Python code generation
  3. AI Assistant for Error Diagnosis: Intelligent failure analysis
  4. AI Assistant for Onboarding: Interactive guide for new users

Process Building Assistant

Section titled “Process Building Assistant”

The Process Building Assistant democratizes automation through an intuitive visual interface that allows any user, without programming knowledge, to design complex workflows.

Key Features

Section titled “Key Features”

Drag-and-Drop Interface

Section titled “Drag-and-Drop Interface”

Create action sequences by dragging and dropping blocks onto a visual canvas:

  • Visual design: Represent your process as a graphical flow of connected actions
  • Intuitive connections: Link blocks with visual connectors to define execution flow
  • Flexible reorganization: Easily reorder blocks to adjust process logic
  • Panoramic view: Visualize your entire process from start to finish on a single screen

Pre-built Block Library

Section titled “Pre-built Block Library”

Access a complete collection of ready-to-use blocks:

Application Blocks:

  • Web browser interaction (Selenium, Playwright)
  • Desktop automation (Windows, macOS)
  • Office integration (Excel, Word, Outlook)
  • Database connection (SQL, MongoDB)
  • APIs and web services

Flow Control Blocks:

  • Conditionals (if/else)
  • Loops (for, while)
  • Exception handling
  • Waits and timers

Data Blocks:

  • File reading and writing
  • Data transformation
  • Validation and cleaning
  • Information extraction

Communication Blocks:

  • Email sending
  • Notifications
  • Webhooks
  • Instant messaging

Visual Flow View

Section titled “Visual Flow View”

The assistant provides different views to understand your process:

Diagram View:

┌─────────────┐
│    Start    │
└──────┬──────┘
       │
┌──────▼──────┐
│  Read Excel │
└──────┬──────┘
       │
┌──────▼──────────┐     ┌──────────────┐
│  Validate Data  ├─────►    Error     │
└──────┬──────────┘     └──────────────┘
       │
┌──────▼──────────┐
│  Process Row    │◄──┐
└──────┬──────────┘   │
       │               │
┌──────▼──────────┐   │
│  More rows?     ├───┘ (Yes)
└──────┬──────────┘
       │ (No)
┌──────▼──────┐
│    End      │
└─────────────┘

List View:

  • Numbered sequence of actions
  • Parameters for each block
  • Comments and annotations

Code View:

  • Automatically generated Python code
  • Mapping between visual blocks and code
  • Read-only mode for verification

Real-Time Validation

Section titled “Real-Time Validation”

The assistant constantly verifies your process logic:

  • Flow error detection: Identifies disconnected blocks or incomplete paths
  • Parameter validation: Verifies that all blocks have valid configuration
  • Dependency checking: Ensures variables are defined before use
  • Best practices alerts: Suggests optimizations and recommended patterns

Use Cases

Section titled “Use Cases”

Report Automation

Section titled “Report Automation”

Design a process that:

  1. Extracts data from multiple sources
  2. Consolidates information into a single format
  3. Generates charts and visualizations
  4. Sends the report by email to stakeholders

Invoice Processing

Section titled “Invoice Processing”

Create a flow that:

  1. Reads invoices from an email inbox
  2. Extracts key information (supplier, amount, date)
  3. Validates data against catalogs
  4. Records information in the ERP
  5. Archives processed documents

Employee Onboarding

Section titled “Employee Onboarding”

Automate the process of:

  1. Creating accounts in multiple systems
  2. Assigning permissions and licenses
  3. Sending credentials securely
  4. Scheduling training sessions
  5. Notifying the relevant team

Best Practices

Section titled “Best Practices”

Process Organization

Section titled “Process Organization”

  1. Divide into logical sections

    • Group related blocks
    • Use comments to separate process phases
    • Name each section descriptively

  2. Robust error handling

    • Include exception capture blocks
    • Define alternative actions for foreseeable failures
    • Implement retries when appropriate

  3. Logic reuse

    • Identify repetitive patterns
    • Create sub-processes for common logic
    • Parameterize blocks for greater flexibility

Clear Naming

Section titled “Clear Naming”
  • Variable names: current_customer, total_invoices, output_file_path
  • Block names: “Validate Customer Email”, “Calculate Total with VAT”
  • Explanatory comments: Document important design decisions

Performance Optimization

Section titled “Performance Optimization”

  1. Minimize costly operations

    • Group file reads
    • Reduce database queries
    • Reuse connections

  2. Parallelization when possible

    • Identify independent tasks
    • Use parallel execution blocks
    • Synchronize results appropriately

AI Assistant for Advanced Blocks

Section titled “AI Assistant for Advanced Blocks”

When pre-built blocks aren’t enough, the AI Assistant for Advanced Blocks generates custom Python code based on natural language descriptions.

How It Works

Section titled “How It Works”

Input: Natural Description

Section titled “Input: Natural Description”

Describe what you need in everyday language:

Description examples:

"I need to extract all email addresses from text that may be in
the format name@domain.com or name@domain.co.uk"
"I want to calculate the net present value of a series of cash
flows with a discount rate of 10% per year"
"I need to convert an XML file with nested structure to a pandas
DataFrame by flattening all levels"
"I need to connect to a REST API with OAuth2 authentication,
get paginated data and combine it into a single dataset"

Intelligent Processing

Section titled “Intelligent Processing”

The assistant analyzes your description to:

  1. Identify functional requirements: What the code should do
  2. Detect necessary technologies: Required libraries and tools
  3. Recognize common patterns: Applicable standard solutions
  4. Evaluate complexity: Estimation of effort and feasibility

Output: Optimized Python Code

Section titled “Output: Optimized Python Code”

The assistant generates code that includes:

Functional code:

import re
from typing import List


def extract_emails(text: str) -> List[str]:
    """
    Extracts all valid email addresses from text.


    Args:
        text: String of text that may contain emails


    Returns:
        List of unique emails found
    """
    # Regex pattern for emails with multi-level domains
    pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'


    # Extract all matches
    emails = re.findall(pattern, text)


    # Remove duplicates while maintaining order
    return list(dict.fromkeys(emails))


# Usage in process context
found_emails = extract_emails(input_text)
print(f"Found {len(found_emails)} unique emails")

Generated code features:

  • Complete documentation: Explanatory docstrings
  • Type hints: Type annotations for clarity
  • Error handling: Try-except where appropriate
  • Useful comments: Explanations of complex logic
  • Idiomatic code: Following Python conventions (PEP 8)
  • Optimization: Efficient algorithms and correct use of data structures

Iteration and Refinement

Section titled “Iteration and Refinement”

The assistant allows iterative adjustments:

  1. Code review: Examine the generated code
  2. Request changes: “Add validation for allowed domains”
  3. Regeneration: The assistant modifies the code according to your instructions
  4. Testing: Run the code in a test environment
  5. Integration: Incorporate the block into the main process

Use Cases

Section titled “Use Cases”

Complex Data Transformations

Section titled “Complex Data Transformations”

Scenario: Normalizing data from multiple sources with inconsistent formats.

Description for the assistant:

"I have sales data from 3 different systems. Each uses different
formats for dates, currencies, and product names. I need to
normalize everything to a standard format where dates are ISO
8601, currencies in EUR, and product names match our master
catalog."

Result: Function that handles multiple input formats and applies business-specific normalization rules.

Custom Integrations

Section titled “Custom Integrations”

Scenario: Connection to a proprietary API without an official library.

Description for the assistant:

"I need to connect to our legacy CRM system's internal API. It
uses token authentication in the 'X-Auth-Token' header, endpoints
are at /api/v2/, and it responds with XML. I want to get all
active customers and convert the response to JSON."

Result: Complete API client with authentication handling, format conversion, and error management.

Specific Business Logic

Section titled “Specific Business Logic”

Scenario: Complex calculations according to unique business rules.

Description for the assistant:

"I need to calculate the applicable discount for an order according
to these rules:
- 5% if the total exceeds €1000
- Additional 10% if premium customer
- Additional 15% if off-season (January-March, July-August)
- Discounts are cumulative but cannot exceed 30%
- If there are promotional products, general discount doesn't apply"

Result: Function that implements all rules with clear, testable logic.

Advanced Analysis and Reports

Section titled “Advanced Analysis and Reports”

Scenario: Generating custom metrics and visualizations.

Description for the assistant:

"I need to analyze sales data and generate a report with:
- Monthly trend with prediction for next 3 months
- Products with highest growth
- Seasonality analysis
- Stacked bar chart by category
- Export results to Excel with conditional formatting"

Result: Complete analysis pipeline with visualizations and formatted export.

Advantages

Section titled “Advantages”

Development Acceleration

Section titled “Development Acceleration”
  • Reduces coding time: From hours to minutes
  • Eliminates documentation search: The assistant knows the libraries
  • Avoids common errors: Tested and validated code
  • Rapid prototyping: Iterate ideas quickly

Development Democratization

Section titled “Development Democratization”
  • Non-technical users: Can create complex logic by describing needs
  • Junior developers: Learn patterns and best practices from generated code
  • Business experts: Translate requirements directly into functional code

Consistent Quality

Section titled “Consistent Quality”
  • Code standards: Always follows best practices
  • Automatic documentation: All code is documented
  • Error handling: Includes robust exception management
  • Security: Avoids anti-patterns and common vulnerabilities

Limitations and Considerations

Section titled “Limitations and Considerations”

Code Complexity

Section titled “Code Complexity”

The assistant works best with:

  • Individual functions or small modules (< 100 lines)
  • Well-defined logic with clear requirements
  • Problems with known or standard solutions

May have difficulties with:

  • Complex multi-module architectures
  • Ambiguous or contradictory requirements
  • Extreme performance optimizations

External Dependencies

Section titled “External Dependencies”
  • Code may require additional libraries that must be installed
  • Some integrations may need additional configuration
  • Consider the implications of adding new dependencies to the project

Performance

Section titled “Performance”
  • Generated code prioritizes clarity and correctness over extreme optimization
  • For cases with critical performance requirements, manual optimization may be necessary
  • Always test with real data volumes before production

AI Assistant for Error Diagnosis

Section titled “AI Assistant for Error Diagnosis”

The AI Assistant for Error Diagnosis transforms the frustration of debugging failures into a guided and educational experience, automatically analyzing errors and providing contextual solutions.

Analysis Capabilities

Section titled “Analysis Capabilities”

Log Analysis

Section titled “Log Analysis”

When a process fails, the assistant examines:

Application logs:

  • Error messages and exceptions
  • Complete stack traces
  • Variable values at time of failure
  • System state during execution

System logs:

  • Available resources (memory, CPU, disk)
  • Active network connections
  • Running processes
  • Operating system events

Process context:

  • Process configuration
  • Input variables
  • History of previous executions
  • Recent changes to the process

Automatic Interpretation

Section titled “Automatic Interpretation”

The assistant translates technical errors into understandable explanations:

Technical error example:

ConnectionError: HTTPSConnectionPool(host='api.example.com', port=443):
Max retries exceeded with url: /v1/users
(Caused by SSLError(SSLCertVerificationError(1,
'[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed:
certificate has expired (_ssl.c:1129)')))

Assistant’s interpretation:

The process couldn't connect to the Example API because the
server's SSL certificate has expired. This is a problem with
the service provider, not your process.


Possible impacts:
- The process cannot obtain user data
- Operations dependent on this API will fail


Service status:
- Verifying service availability... ✓
- Service is active but with invalid certificate

Error Categorization

Section titled “Error Categorization”

The assistant classifies errors by type and severity:

Error types:

  • Configuration: Incorrect credentials, invalid paths
  • Data: Unexpected format, missing values
  • Network: Timeouts, rejected connections
  • Logic: Unhandled conditions, division by zero
  • Resources: Insufficient memory, full disk
  • External: Down APIs, unavailable services

Severity levels:

  • Critical: Process completely blocked
  • High: Main functionality affected
  • Medium: Secondary functionality affected
  • Low: Warnings or minor issues

Contextual Suggestions

Section titled “Contextual Suggestions”

The assistant provides specific recommendations based on:

Error Type

Section titled “Error Type”

Credentials error:

Diagnosis: Credentials to access SAP are incorrect.


Recommendations:
1. Verify that user 'SAP_USER' exists and is active
2. Confirm that password hasn't expired
3. Check that user has sufficient permissions
4. Update secret 'SAP_PASSWORD' in local robot


Steps to resolve:
→ Open robot secrets management
→ Locate secret 'SAP_PASSWORD'
→ Update with correct password
→ Retry process

Data format error:

Diagnosis: Excel file has a different structure than expected.


Details:
- Expected: column 'Customer Name' in position 1
- Found: column 'CustomerName' in position 2


Recommendations:
1. Verify that correct template is being used
2. Update process to handle both formats
3. Implement structure validation before processing


Code suggestion:
# Flexible column mapping
expected_columns = {'Customer Name', 'CustomerName', 'customer_name'}
name_column = next((col for col in df.columns if col in expected_columns), None)

Process History

Section titled “Process History”

The assistant compares with previous executions:

History analysis:
- Last 10 executions: 9 successful, 1 failed (current)
- Process failed for the first time today at 2:30 PM
- Detected change: Input file with 50% more records than usual
- Possible cause: Timeout due to larger data volume


Recommendation:
Increase timeout from 60s to 120s or implement batch processing
for large files.

Best Practices

Section titled “Best Practices”
Observation: Process doesn't implement retries for API calls.


Best practices not applied:
- No automatic retries for transient errors
- Complete error detail is not logged
- No proactive failure notification


Improvement recommendations:
1. Implement exponential backoff retry strategy
2. Add detailed logging of requests/responses
3. Configure email alerts for critical errors


Want the assistant to generate code for these improvements?

Next Steps

Section titled “Next Steps”

The assistant provides step-by-step guidance to resolve the problem:

Guided Resolution

Section titled “Guided Resolution”

Step 1: Verification

✓ Identify affected component
→ Verify component status
→ Confirm problem existence

Step 2: Correction

→ Apply recommended solution
→ Document change made
→ Execute correction validation

Step 3: Validation

→ Retry failed operation
→ Verify error doesn't repeat
→ Check functionality is complete

Step 4: Prevention

→ Implement monitoring for early detection
→ Update documentation with problem and solution
→ Consider improvements to avoid recurrence

Automatic Actions

Section titled “Automatic Actions”

In some cases, the assistant can:

  • Auto-correct minor errors: Simple configuration adjustments
  • Restart components: Problematic services or connections
  • Update configuration: Automatically optimized parameters
  • Notify stakeholders: Automatic alerts according to severity

Continuous Learning

Section titled “Continuous Learning”

The assistant improves with each diagnosed error:

Knowledge Base

Section titled “Knowledge Base”
  • Unique errors: Cataloged for future reference
  • Effective solutions: Prioritized in future recommendations
  • Common patterns: Identified and documented
  • False positives: Adjusted to improve accuracy

Organizational Personalization

Section titled “Organizational Personalization”

The assistant learns specific characteristics of your environment:

  • Frequently used systems and applications
  • Corporate configuration patterns
  • Recurring errors and their solutions
  • Typical response times of external services
Section titled “Metrics and Trends”

The assistant generates insights about:

Error Report - Last Month


Most frequent errors:
1. CRM API Timeout (15 occurrences)
   → Recommendation: Review CRM server capacity


2. File not found (8 occurrences)
   → Pattern: Always same process, different files
   → Recommendation: Implement prior existence validation


3. Invalid date format (5 occurrences)
   → Pattern: Data from external system without normalization
   → Recommendation: Add date normalization block


Average resolution time: 12 minutes
Automatic resolutions: 45%
Guided resolutions: 55%

Workflow Integration

Section titled “Workflow Integration”

Proactive Notifications

Section titled “Proactive Notifications”

When an error occurs:

  1. Immediate notification to responsible user
  2. Diagnosis summary in notification
  3. Direct link to assistant with loaded context
  4. Initial suggestions without needing to open platform

Diagnosis Dashboard

Section titled “Diagnosis Dashboard”

Centralized interface showing:

  • Active errors requiring attention
  • Errors in process of resolution
  • Recently resolved errors
  • Identified trends and patterns
  • Proactive improvement recommendations

Automatic Documentation

Section titled “Automatic Documentation”

The assistant generates documentation of:

  • Errors and their solutions
  • Decisions made during resolution
  • Changes applied to process
  • Lessons learned

AI Assistant for Onboarding

Section titled “AI Assistant for Onboarding”

The AI Assistant for Onboarding transforms the new user experience, guiding them from first contact with the platform to creating their first successful automations.

Initial Assessment

Section titled “Initial Assessment”

The assistant begins by getting to know the user:

User Profile

Section titled “User Profile”

Assessment questions:

Welcome to Heptora. To personalize your experience,
tell me a bit about yourself:


1. What is your main role?
   [ ] Developer / Technical
   [ ] Business Analyst
   [ ] Manager / Director
   [ ] End User


2. How much experience do you have with automation?
   [ ] None - I'm new to this
   [ ] Basic - I've used simple tools
   [ ] Intermediate - I've created some processes
   [ ] Advanced - I'm an RPA/automation expert


3. How much do you know about programming?
   [ ] Nothing - I've never programmed
   [ ] Basic - I understand simple concepts
   [ ] Intermediate - I can write scripts
   [ ] Advanced - I'm a professional developer


4. What type of tasks do you need to automate?
   [ ] Document processing
   [ ] System integration
   [ ] Analysis and reports
   [ ] Repetitive office tasks
   [ ] Other: _____________

Needs Analysis

Section titled “Needs Analysis”

Based on responses, the assistant determines:

  • Assistance level: Step-by-step guide vs. quick references
  • Initial complexity: Simple processes vs. advanced cases
  • Focus: Visual/no-code vs. custom code
  • Resources: Detailed tutorials vs. technical documentation

Process Recommendations

Section titled “Process Recommendations”

The assistant suggests relevant use cases:

Section titled “Recommended Templates”

For a Finance Analyst:

Based on your profile, these templates may be useful:


1. 📊 Automatic Financial Report Consolidation
   Difficulty: ⭐⭐ Basic
   Time: 10 minutes setup


   This process will help you:
   - Collect data from multiple Excel sheets
   - Consolidate into a master report
   - Generate automatic charts
   - Send by email to stakeholders


   [Use this template]


2. 💰 Invoice Validation vs Purchase Orders
   Difficulty: ⭐⭐⭐ Intermediate
   Time: 20 minutes setup


   This process automates:
   - Reading PDF invoices
   - Extracting key data
   - Comparison with purchase orders
   - Marking discrepancies


   [Use this template]


3. 📈 Automatic Executive Dashboard
   Difficulty: ⭐⭐⭐⭐ Advanced
   Time: 30 minutes setup


   Automatically generates:
   - Updated financial KPIs
   - Trend charts
   - Previous period comparisons
   - Out-of-range metric alerts


   [Use this template]

For an IT Administrator:

Recommended processes for your role:


1. 🔧 User Provisioning
   Automates account creation in multiple systems


2. 🔐 Permission Auditing
   Reviews and reports user access periodically


3. 📦 Update Management
   Downloads, tests and deploys software updates

Custom Use Cases

Section titled “Custom Use Cases”

If there’s no exact template, the assistant proposes:

I didn't find an exact template for "inventory synchronization
between ERP and e-commerce", but I can help you create a
custom process.


Proposed process:


Phase 1: Data Extraction
- Connect with your ERP (SAP/Oracle/Odoo)
- Get updated inventory
- Filter active products for online sale


Phase 2: Transformation
- Map ERP fields to e-commerce format
- Apply business rules (prices, availability)
- Validate data before sending


Phase 3: Loading
- Connect with your e-commerce API (Shopify/WooCommerce/Magento)
- Update inventory and prices
- Handle errors and discrepancies


Phase 4: Monitoring
- Log successful synchronization
- Alert about unsynchronized products
- Generate change report


Want me to guide you to create this process?
[Yes, let's start] [See other examples]

Personalized Tutorial

Section titled “Personalized Tutorial”

The assistant creates adapted learning paths:

Path for Non-Technical Users

Section titled “Path for Non-Technical Users”

Module 1: Basic Concepts (10 minutes)

Lesson 1.1: What is a Process?
- Explanatory video (2 min)
- Interactive diagram
- Verification quiz


Lesson 1.2: Blocks and Actions
- Explorer of available blocks
- Common usage examples
- Practical exercise: Drag and drop


Lesson 1.3: Variables and Data
- What are variables?
- How to use data between blocks
- Visual examples

Module 2: Your First Process (20 minutes)

Guided Project: Read an Excel and send summary by email


Step 1: Create the process
→ Assistant creates base structure
→ You add Excel reading block
✓ Automatic verification


Step 2: Configure the file
→ Select your Excel file
→ Choose important columns
✓ Data preview


Step 3: Process information
→ Automatic summary block
→ Result visualization
✓ Data processed correctly


Step 4: Send by email
→ Configure recipients
→ Personalize message
→ Execute and verify
✓ Process completed!

Module 3: Improvements and Optimization (15 minutes)

Lesson 3.1: Error Handling
- What can go wrong?
- How to add safety blocks
- Practice: Add validation to your process


Lesson 3.2: Execution Scheduling
- Run automatically every day/week/month
- Configure schedules
- Practice: Schedule your process


Lesson 3.3: Next Steps
- Explore more templates
- Join the community
- Additional resources

Path for Developers

Section titled “Path for Developers”

Module 1: Architecture and Concepts (15 minutes)

- Hybrid cloud-local architecture
- Available APIs and SDKs
- Execution model and lifecycle
- Variables, secrets and configuration
- Integration with Git and CI/CD

Module 2: Advanced Development (30 minutes)

- Using the advanced blocks assistant
- Integration of custom Python code
- Dependency and environment management
- Process testing and debugging
- Recommended design patterns

Module 3: Best Practices (20 minutes)

- Performance optimization
- Security and credential handling
- Logging and monitoring
- Versioning and deployment
- Scalability and maintenance

Guided Configuration

Section titled “Guided Configuration”

The assistant helps with initial setup:

Variables and Parameters

Section titled “Variables and Parameters”
For your process to work, we need to configure some variables:


Variable: RECIPIENT_EMAIL
Description: Email where report will be sent
Suggested value: your_email@company.com
[ Enter value: _________________ ]


Variable: FILES_PATH
Description: Folder where files to be processed are located
Suggested value: C:\Users\YourUser\Documents\Reports
[ Select folder 📁 ]


Variable: EXECUTION_FREQUENCY
Description: How often should it run?
[ ] Daily
[ ] Weekly (Monday)
[X] Monthly (first day of month)


All set? [Save configuration]

Secrets and Credentials

Section titled “Secrets and Credentials”
Your process needs to access external systems.
Let's configure credentials securely:


🔐 Secret: SAP_USER
For: Access to SAP system
Will be saved: Encrypted in your local robot
[ Configure now ] [ Configure later ]


💡 Tip: Secrets are never stored in the cloud.
Only your local robot knows the values.


Need help creating a service user?
[See best practices guide]

External Connections

Section titled “External Connections”
Let's configure the connection with your e-commerce:


Detected platform: Shopify
Your store URL: example.myshopify.com


You will need:
1. Shopify API Key
   [ ] I already have it
   [X] I need to create it


If you need to create it:
→ Step 1: Go to your Shopify panel
→ Step 2: Settings > Apps and sales channels
→ Step 3: Develop apps > Create an app
→ Step 4: Copy the API Key
→ Step 5: Paste it here: _______________


[Video tutorial: How to get Shopify API Key] (2:30)


Is the API Key ready? [Test connection]

First Processes

Section titled “First Processes”

The assistant guides step-by-step creation:

Interactive Approach

Section titled “Interactive Approach”
Let's create your first process together!


You chose: Excel Report Consolidation


I will take care of:
✓ Creating the process structure
✓ Configuring necessary blocks
✓ Establishing connections between steps


You only need to:
→ Answer some questions
→ Provide sample files
→ Verify results are correct


Ready? [Let's start!]

Contextual Assistance

Section titled “Contextual Assistance”

During creation, the assistant offers:

Inline Help:

You're adding a "Read Excel" block


This block reads data from Excel files (.xlsx, .xls)
and converts them to a table you can process.


Parameters:
- File path: Where is your file?
  [ ] Fixed path: C:\...\file.xlsx
  [ ] Use variable: file_path
  [Help: When to use each option?]


- Sheet to read: Which Excel sheet?
  [ ] First sheet
  [ ] Specific sheet: [name___________]
  [ ] All sheets


- Does the file have headers in the first row?
  [X] Yes [ ] No


[Data preview] [Continue]

Real-Time Validation:

⚠️ Warning detected


You've selected "All sheets" but the next block
expects a single data table.


Suggestions:
1. Select a specific sheet
2. Add a block to combine multiple sheets
3. Process each sheet separately in a loop


What do you prefer to do?
[Option 1] [Option 2] [Option 3] [Explain more]

Milestone Celebration:

🎉 Excellent!


You've completed the data reading configuration.


Process progress:
[████████░░░░░░░░░░░░] 40%


✅ Data reading
🔄 Information processing <- You are here
⏳ Report generation
⏳ Email sending


Next step: Configure information processing
[Continue] [Take a break]

Best Practices

Section titled “Best Practices”

The assistant recommends patterns and optimizations:

Contextual Recommendations

Section titled “Contextual Recommendations”
💡 Suggestion: Error Handling


I've noticed your process doesn't have error handling.
What happens if the Excel file doesn't exist or is corrupted?


I recommend adding:
1. File validation block before reading
2. Exception capture block
3. Notification in case of error


Want me to add this automatically?
[Yes, add protection] [Not now] [Explain more]

Design Patterns

Section titled “Design Patterns”
Detected Pattern: Processing Multiple Files


I see your process handles several similar Excel files.
This is a common pattern. I recommend:


"Batch Processing" Pattern:
┌─────────────────────┐
│   List Files        │
└──────┬──────────────┘
       │
┌──────▼──────────────┐
│  For each file:     │ ◄──┐
│   - Read            │    │
│   - Process         │    │
│   - Log             │    │
└──────┬──────────────┘    │
       │                    │
       └────────────────────┘


Advantages:
- Processes all files automatically
- Handles new files without modifying process
- Logs progress for each file
- Continues if a file fails


[Apply this pattern] [See other patterns]

Optimizations

Section titled “Optimizations”
🚀 Optimization Opportunity


Your process reads the same file multiple times.
This is slow and unnecessary.


Suggested optimization:
- Read the file once at the start
- Save the data in a variable
- Reuse the variable in subsequent steps


Estimated performance improvement: 60% faster


[Apply optimization] [Explain in detail]

Adaptive Progress

Section titled “Adaptive Progress”

The assistant adjusts according to user experience:

Gradual Assistance Reduction

Section titled “Gradual Assistance Reduction”

First time:

Step 1: Add an email block
→ Click the "+" button in the flow
→ Select "Communication" in the menu
→ Choose "Send Email"
→ Drag the block to the canvas
✓ Perfect! Now configure it...

Fifth time:

Step 1: Add an email block
[You already know how to do this]


Need help? [Show detailed instructions]

Tenth time:

💡 Quick tip: Keyboard shortcut 'E' to add email

Introduction of Advanced Concepts

Section titled “Introduction of Advanced Concepts”
🎓 You're ready for the next level


You've successfully created 5 basic processes.
It's time to learn more advanced concepts:


1. ⚡ Sub-processes and Reuse
   How to create reusable blocks


2. 🔄 Advanced Error Handling
   Retries, fallbacks and recovery


3. 🎯 Performance Optimization
   Parallel execution and efficiency


4. 🐍 Custom Python Code
   Going beyond pre-built blocks


What would you like to learn first?
[Sub-processes] [Errors] [Performance] [Python] [Later]

Skill Certification

Section titled “Skill Certification”
🏆 Unlocked Achievements


✓ First Process Created
✓ 10 Processes in Production
✓ Advanced Blocks Usage
✓ Secrets Configuration
✓ Error Handling Implemented


Next achievements:
⏳ Create a Sub-process (5/10 steps)
⏳ Optimization Expert (0/5 optimizations)
⏳ Integration Master (2/10 APIs connected)


Overall progress: Level 3 - Competent User
[View all achievements] [Share progress]

Integration Between Assistants

Section titled “Integration Between Assistants”

The four assistants work in coordinated fashion:

Integrated Flow

Section titled “Integrated Flow”
New User → Onboarding Assistant
            ↓
         Create Process → Building Assistant
                          ↓
                      Needs Complex Logic → Advanced Blocks Assistant
                                            ↓
                                         Process Fails → Diagnosis Assistant
                                                          ↓
                                                       Solution → Learning
                                                                  ↓
                                                               Continuous Improvement

Interaction Example

Section titled “Interaction Example”
User: "I want to automate data extraction from PDFs"


Onboarding Assistant:
"I see you need to extract data from PDFs. I recommend the
'Invoice Processing' template. Want to set it up?"


[User accepts]


Building Assistant:
"I've created the base process. Now add a 'Read PDF' block..."


[User configures block]


User: "I need to extract specific fields with complex format"


Advanced Blocks Assistant:
"I can generate Python code to extract those fields. Describe
the exact format you need..."


[Generates custom code]


[During execution, an error occurs]


Diagnosis Assistant:
"The PDF has a protected structure. I recommend using the
'ignore_security=True' parameter in the read block..."


[User applies solution]


Onboarding Assistant:
"Process completed successfully! You've learned about:
- PDF reading
- Custom Python code
- Error resolution


Want to learn about OCR for scanned PDFs?"

General Best Practices

Section titled “General Best Practices”

Make the Most of Assistants

Section titled “Make the Most of Assistants”

  1. Be specific in your descriptions

    • The more detailed your request, the better the result
    • Include examples of expected inputs and outputs
    • Mention restrictions or special requirements

  2. Iterate and refine

    • Assistants learn from your corrections
    • Don’t hesitate to ask for adjustments and improvements
    • Try different approaches

  3. Document your processes

    • Assistants help with automatic documentation
    • Add explanatory comments at key points
    • Keep a record of important decisions

  4. Share knowledge

    • Successful solutions benefit your entire organization
    • Identified patterns are reused in future processes
    • Contribute to the collective knowledge base

Security and Privacy

Section titled “Security and Privacy”

  1. Review generated code

    • Especially for operations with sensitive data
    • Verify that credentials are not exposed
    • Confirm compliance with corporate policies

  2. Limit permissions

    • Use credentials with minimum necessary privileges
    • Don’t share secrets between processes unnecessarily
    • Review permissions periodically

  3. Auditing and logging

    • Enable detailed logging in critical processes
    • Review logs regularly
    • Configure alerts for suspicious activity

Troubleshooting

Section titled “Troubleshooting”

Assistants don’t respond or are slow

Section titled “Assistants don’t respond or are slow”

Possible causes:

  • High system load
  • Unstable internet connection
  • Very complex process

Solution:

  1. Verify your internet connection
  2. Try with a simpler description
  3. Divide complex tasks into smaller steps
  4. If problem persists, contact support

Suggestions are not relevant

Section titled “Suggestions are not relevant”

Possible causes:

  • Ambiguous or incomplete description
  • Insufficient context
  • Assistant needs more information

Solution:

  1. Provide more details about your use case
  2. Include concrete examples
  3. Specify requirements and restrictions
  4. Use feedback to improve suggestions

Generated code doesn’t work

Section titled “Generated code doesn’t work”

Possible causes:

  • Missing dependencies
  • Incorrect environment configuration
  • Problem description doesn’t match code

Solution:

  1. Verify all libraries are installed
  2. Review specific error messages
  3. Use Diagnosis Assistant for analysis
  4. Provide error to assistant for correction

Onboarding Assistant doesn’t progress

Section titled “Onboarding Assistant doesn’t progress”

Possible causes:

  • Steps not completed correctly
  • Synchronization problems
  • Incomplete configuration

Solution:

  1. Review that you’ve completed all required steps
  2. Reload the assistant interface
  3. Verify your progress in the achievements panel
  4. Contact support if problem persists

Frequently Asked Questions

Section titled “Frequently Asked Questions”

Do assistants work without internet connection?

Section titled “Do assistants work without internet connection?”

The Process Building Assistant works locally, but AI assistants (Advanced Blocks, Diagnosis, Onboarding) require internet connection to access artificial intelligence models.

Can I disable assistants?

Section titled “Can I disable assistants?”

Yes, you can configure the assistance level in preferences. You can choose:

  • Complete assistance (recommended for new users)
  • Occasional suggestions
  • Only on demand
  • Disabled (only for advanced users)

Do assistants learn from my processes?

Section titled “Do assistants learn from my processes?”

Assistants learn general patterns and best practices, but your specific processes and data remain private. Learning is performed in an aggregated and anonymous manner.

What data is sent to AI assistants?

Section titled “What data is sent to AI assistants?”

Only sent:

  • Descriptions of requested functionality
  • Process structure (without sensitive data)
  • Error types and technical context (without credentials)
  • Aggregated usage metrics

Never sent:

  • Secret or credential values
  • Processed business data
  • Personally identifiable information
  • Content of processed files

Can I use assistants in multiple languages?

Section titled “Can I use assistants in multiple languages?”

Yes, assistants support multiple languages including Spanish, English, French, German, Portuguese and Italian. Language is detected automatically or can be configured manually.

Are there limits on assistant usage?

Section titled “Are there limits on assistant usage?”

Limits depend on your Heptora plan:

  • Free plan: Limited use of AI assistants
  • Professional plan: Generous use with high limits
  • Enterprise plan: No limits, with priority in responses

Can I share code generated by assistants?

Section titled “Can I share code generated by assistants?”

Yes, code generated by assistants is yours. You can share, modify and reuse it freely. We recommend reviewing and adapting code to your specific needs before sharing widely.

Do assistants replace the need for developers?

Section titled “Do assistants replace the need for developers?”

No, assistants complement team skills. They accelerate development for technical users and allow non-technical users to create simple automations, but complex or critical processes still benefit from professional developer expertise.

Need more help?

Section titled “Need more help?”

If this guide didn’t solve your problem or you found an error in the documentation:

  • Technical support: help@heptora.com
  • Community: community.heptora.com
  • Live chat: Available on the web platform
  • Clearly describe the problem you encountered
  • Include screenshots if possible
  • Indicate which assistant you were using and what you were trying to do

Our support team will help you make the most of Heptora’s intelligent assistants.

Section titled “Related Resources”