Integrations (Apps)

Integrations (Apps) allow your AI Builder applications to connect with external systems, databases, APIs, and services. This connectivity is essential for creating AI solutions that work within your existing technology ecosystem and deliver real business value.

Integration Fundamentals

AI Builder supports various integration approaches:

API Integrations: Connect to external services via REST, GraphQL, or other API protocols
Database Connections: Access and manipulate data in various database systems
Webhook Mechanisms: Receive and send event notifications to external systems
File System Operations: Read, write, and process files in various formats
Authentication Systems: Connect with identity providers and SSO solutions
Marketplace Apps: Pre-built integrations installed from the app marketplace

Each type serves different integration needs and scenarios.

API Integrations

HTTP Connections

Connect to external APIs using HTTP requests.HTTP integration supports:

Methods: GET, POST, PUT, DELETE, PATCH
Headers: Custom headers for authentication and metadata
Query Parameters: URL parameters for request configuration
Request Bodies: JSON, XML, form data, and other formats
Response Handling: Processing various response formats and status codes

HTTP is the foundation for most modern API integrations.

Authentication Setup

Configure secure authentication for API access.Authentication methods include:

API Keys: Simple key-based authentication
OAuth 2.0: Token-based authentication flow
Basic Auth: Username/password authentication
JWT: JSON Web Token authentication
Custom Schemes: Specialized authentication mechanisms

Proper authentication ensures secure access to protected resources.

Data Transformation

Process data between your application and external APIs. Transformation capabilities include:

Format Conversion: Between JSON, XML, CSV, and other formats
Field Mapping: Align field names and structures
Data Filtering: Include only relevant information
Aggregation: Combine data from multiple sources
Normalization: Standardize data formats and values

Transformation ensures compatibility between systems with different data models.

Error Handling

Implement robust error management strategies. Error handling approaches:

Status Code Handling: Respond to different HTTP status codes
Retry Logic: Attempt failed requests again
Fallback Strategies: Alternative approaches when integrations fail
Error Logging: Record detailed error information
User Feedback: Provide appropriate information to users

Effective error handling creates resilient integrations that gracefully handle failures.

Database Integrations

Connect to various database systems to work with structured data:

Connect to SQL databases such as:

MySQL
PostgreSQL
SQL Server
Oracle
SQLite

Example configuration for a PostgreSQL connection:

connection:
  type: postgresql
  host: database.example.com
  port: 5432
  database: customer_data
  username: "{{secrets.DB_USERNAME}}"
  password: "{{secrets.DB_PASSWORD}}"
  ssl: true
  pool:
    min: 5
    max: 20

Webhook Integrations

Implement event-driven integrations with external systems:

Inbound Webhooks

Receive events and notifications from external systems:

Endpoint Creation: Generate unique webhook URLs
Authentication: Verify webhook sources
Payload Processing: Parse and validate incoming data
Event Routing: Direct webhooks to appropriate handlers
Response Generation: Acknowledge receipt with appropriate responses

Example automation for receiving GitHub webhooks:

[Trigger: API (webhook)]
↓
[Verify Signature: github-signature header]
↓
[Condition: Valid signature?]
├─ [Yes] → [Parse webhook payload]
│           ↓
│           [Switch: Based on event type]
│           ├─ [push] → [Process code push]
│           ├─ [issue] → [Process issue update]
│           └─ [release] → [Process release]
│
└─ [No] → [Log security warning]
           ↓
           [Return 401 Unauthorized]

Outbound Webhooks

Send events and notifications to external systems:

Destination Configuration: Configure target URLs
Payload Formatting: Structure event data appropriately
Authentication: Add necessary authentication
Delivery Confirmation: Verify successful delivery
Retry Management: Handle delivery failures

Example automation for sending a Slack notification:

[Trigger: New document created event]
↓
[Format Webhook Payload]
↓
[HTTP Request: POST to Slack webhook URL]
↓
[Condition: Successful delivery?]
├─ [Yes] → [Log successful notification]
│
└─ [No] → [Retry logic]
           ↓
           [If still failing after retries, log error]

Webhook Security

Implement secure webhook patterns:

Signature Verification: Validate webhook authenticity
Payload Encryption: Protect sensitive data
Rate Limiting: Prevent abuse
IP Restrictions: Limit webhook sources
Payload Validation: Ensure data meets expectations

Example HMAC signature verification logic:

const crypto = require('crypto');

function verifyWebhook(payload, secret, signature) {
  const hmac = crypto.createHmac('sha256', secret);
  const computedSignature = hmac.update(payload).digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(computedSignature),
    Buffer.from(signature)
  );
}

Authentication & Authorization

Secure your integrations with robust authentication and authorization:

Authenticate with external services:

API Keys: Simple key-based authentication
OAuth 2.0: Token-based authentication with various flows
- Authorization Code
- Client Credentials
- Resource Owner Password
- Implicit Flow
Bearer Tokens: Token-based authentication
Basic Authentication: Username/password encoded in headers
Custom Authentication: Specialized methods for specific services

File System Integrations

Work with files in various storage systems:

Local File System

Access files within the workspace environment:

File Reading: Load file contents
File Writing: Create or update files
Directory Operations: List, create, delete directories
File Properties: Get metadata about files
Path Management: Work with file paths

Example file reading operation:

// Read a file asynchronously
const content = await fs.readFile('/path/to/file.txt', 'utf8');
console.log(content);

// Write to a file
await fs.writeFile('/path/to/output.txt', 'Hello, world!', 'utf8');

Cloud Storage

Connect to cloud-based storage services:

AWS S3: Amazon Simple Storage Service
Azure Blob Storage: Microsoft’s object storage
Google Cloud Storage: Google’s object storage
Dropbox: File hosting service
OneDrive/SharePoint: Microsoft’s document storage

Example S3 integration configuration:

storage:
  type: s3
  region: us-west-2
  bucket: my-application-files
  accessKeyId: "{{secrets.AWS_ACCESS_KEY_ID}}"
  secretAccessKey: "{{secrets.AWS_SECRET_ACCESS_KEY}}"
  defaultACL: private

Document Processing

Process various document formats:

PDF: Parse and extract PDF content
Office Documents: Work with Word, Excel, PowerPoint
CSV/TSV: Process structured data files
JSON/XML: Parse and generate structured formats
Images: Process image files with OCR

Example document processing automation:

[Trigger: File uploaded event]
↓
[Condition: File type?]
├─ [PDF] → [Extract text from PDF]
├─ [DOCX] → [Extract text from Word document]
├─ [XLSX] → [Extract tables from Excel]
├─ [Image] → [Perform OCR on image]
└─ [Other] → [Return unsupported format error]
↓
[Process extracted content]
↓
[Store results]

Marketplace Integration Apps

Accelerate integration with pre-built marketplace apps:

Browsing Available Apps

Explore the integration apps in the marketplace.The marketplace provides:

Categorized integration listings
Detailed descriptions and capabilities
User ratings and reviews
Documentation and examples
Version history and updates

Installing Integration Apps

Add integrations to your workspace.The installation process:

Select the desired app from the marketplace
Review permissions and capabilities
Approve the installation
Configure app-specific settings
Set up authentication if required

Configuring Integration Apps

Set up the integration for your specific needs. Configuration typically includes:

Connection settings (endpoints, hosts)
Authentication credentials
Default behavior options
Logging and monitoring preferences
Feature toggles and limitations

Using Integration Components

Leverage the integrated functionality in your workspace. Integration apps provide:

Custom blocks for UI integration
Automation instructions for backend integration
Events for integration state changes
Documentation on usage patterns
Examples for common scenarios

Popular Integration Categories

Productivity & Collaboration

Connect with common workplace tools:

Microsoft 365 (Outlook, Teams, SharePoint)

Google Workspace (Gmail, Drive, Calendar)

Slack

Zoom

Trello, Asana, Monday.com

CRM & Sales

Integrate with customer relationship platforms:

Salesforce

HubSpot

Dynamics 365

Zendesk

Pipedrive

Data & Analytics

Connect to data platforms and analytics tools:

Snowflake

Databricks

Power BI

Tableau

Looker

Enterprise Systems

Integrate with core business systems:

SAP

Oracle ERP

ServiceNow

Workday

NetSuite

Developer Tools

Connect with development and DevOps platforms:

GitHub

GitLab

Jira

Azure DevOps

Bitbucket

AI & Machine Learning

Integrate with AI and ML services:

OpenAI

Azure Cognitive Services

Google Vertex AI

Hugging Face

AWS AI Services

Creating Custom Integrations

For specialized requirements, develop your own integrations:

Create integrations using existing automation capabilities:

Combine HTTP requests with data transformations
Set up authentication flows
Implement error handling and retries
Create event-based integration patterns
Build data synchronization processes

This approach requires no coding but may be limited for complex scenarios.

Integration Best Practices

Security First

Prioritize security in all integrations:

Use secure authentication methods

Store credentials in workspace secrets

Implement the principle of least privilege

Validate and sanitize all inputs

Encrypt sensitive data in transit and at rest

Error Resilience

Build robust error handling:

Implement appropriate retry strategies

Create circuit breakers for failing services

Log detailed error information

Provide meaningful error messages

Have fallback options for critical paths

Performance Optimization

Ensure efficient integration operations:

Use connection pooling for databases

Implement caching where appropriate

Process large datasets in batches

Use asynchronous operations when possible

Monitor and optimize slow integrations

Monitoring & Logging

Maintain visibility into integration health:

Log key integration events

Track performance metrics

Set up alerts for integration failures

Monitor usage patterns and quotas

Implement audit trails for sensitive operations

Versioning Strategy

Manage integration changes safely:

Plan for API version changes

Test integrations before upgrading

Maintain backward compatibility

Document integration requirements

Implement graceful degradation

Data Governance

Respect data policies and regulations:

Understand data residency requirements

Implement data minimization principles

Follow retention policies

Handle PII according to regulations

Document data flows for compliance

Integration Troubleshooting

Authentication Issues

Connection Problems

Data Format Issues

Performance Issues

Webhook Debugging

Using the Activity Log

AI Knowledge Webhook Integration

Implementing advanced integrations with AI Knowledge requires AI Builder and subscription to specific webhook events. This advanced functionality enables custom RAG pipelines and sophisticated AI agent behaviors.

AI Builder enables powerful integration with AI Knowledge through webhooks:

Subscribe to document events to enhance the knowledge base:

documents_created: Triggered when new documents are added
documents_updated: Triggered when documents are modified
documents_deleted: Triggered when documents are removed

Example use cases:

Custom document processing pipelines
Content enrichment with additional metadata
Advanced document validation
Integration with document management systems

Next Steps

Automations

Learn more about the backend processes that power integrations

Testing & Debugging

Explore how to troubleshoot and validate your integrations

RBAC

Understand how to secure access to integrations

Use Cases

See examples of integrations in real-world applications

Overview

AI SecureChat

AI Store

AI Knowledge

AI Builder

AI Governance

AI Collection (beta)

AI Insights (beta)

Integrations (Apps)

Integration Fundamentals

API Integrations

Database Integrations

Webhook Integrations

Authentication & Authorization

File System Integrations

Marketplace Integration Apps

Popular Integration Categories

Productivity & Collaboration

CRM & Sales

Data & Analytics

Enterprise Systems

Developer Tools

AI & Machine Learning

Creating Custom Integrations

Integration Best Practices

Security First

Error Resilience

Performance Optimization

Monitoring & Logging

Versioning Strategy

Data Governance

Integration Troubleshooting

AI Knowledge Webhook Integration

Next Steps

Automations

Testing & Debugging

RBAC

Use Cases

Overview

AI SecureChat

AI Store

AI Knowledge

AI Builder

AI Governance

AI Collection (beta)

AI Insights (beta)

​Integration Fundamentals

​API Integrations

​Database Integrations

​Webhook Integrations

​Authentication & Authorization

​File System Integrations

​Marketplace Integration Apps

​Popular Integration Categories

Productivity & Collaboration

CRM & Sales

Data & Analytics

Enterprise Systems

Developer Tools

AI & Machine Learning

​Creating Custom Integrations

​Integration Best Practices

Security First

Error Resilience

Performance Optimization

Monitoring & Logging

Versioning Strategy

Data Governance

​Integration Troubleshooting

​AI Knowledge Webhook Integration

​Next Steps

Automations

Testing & Debugging

RBAC

Use Cases

Integration Fundamentals

API Integrations

Database Integrations

Webhook Integrations

Authentication & Authorization

File System Integrations

Marketplace Integration Apps

Popular Integration Categories

Creating Custom Integrations

Integration Best Practices

Integration Troubleshooting

AI Knowledge Webhook Integration

Next Steps