Make.com Integration¶

Make.com (formerly Integromat) is a visual automation platform that connects apps and services through scenarios. By integrating Make.com with Beyond Retrieval v2, you can build automated pipelines for document ingestion, RAG-powered chatbots, scheduled health monitoring, and instant Q&A from form submissions.

Prerequisites¶

Authentication Setup¶

Make.com does not have a built-in Beyond Retrieval connector, so you will use the HTTP module with manual header configuration.

Option A: Header in Each Module¶

Add the Authorization header directly to every HTTP module:

Option B: Reusable Connection (Recommended)¶

Create a custom connection for reuse across modules:

1. In your scenario, add an HTTP > Make a request module.
2. Click Add next to the connection dropdown.
3. Select API Key as the type.
4. Configure:

1. Save the connection. It can be reused in all HTTP modules within your scenarios.

HTTP Module — Base Configuration¶

Every API call uses the HTTP > Make a request module with these defaults:

Parsing the Response Envelope¶

Beyond Retrieval wraps every response in a standard envelope:

{
  "success": true,
  "data": { ... },
  "error": null
}

In Make.com, after the HTTP module executes with Parse response: Yes, access fields with dot notation:

• {{data.assistant_message.content}} — AI response text
• {{data.health_score}} — health check score
• {{success}} — boolean success flag
• {{error}} — error message (null on success)

Example Scenarios¶

1. Google Drive to Beyond Retrieval Ingestion¶

Watch a Google Drive folder for new files, download them, upload to Beyond Retrieval, and trigger ingestion.

graph LR
    A[Google Drive: Watch Files] --> B[Google Drive: Download File]
    B --> C[HTTP: Upload to BR]
    C --> D[Router]
    D -->|Success| E[HTTP: Start Ingestion]
    D -->|Failure| F[Slack: Notify Error]
    E --> G[Sleep 15s]
    G --> H[HTTP: Check Stage]
    H --> I[Router]
    I -->|Processing| G
    I -->|Done| J[Slack: Notify Complete]

Module 1 — Google Drive: Watch Files

Module 2 — Google Drive: Download a File

Module 3 — HTTP: Upload to Beyond Retrieval

Add a field:

Module 4 — Router

Add a router with two routes:

• Route 1 (Success): Filter condition {{3.data.success}} equals true
• Route 2 (Failure): Fallback route

Module 5 — HTTP: Start Ingestion

{
  "files": [
    {
      "file_id": "{{3.data[1].file_id}}",
      "file_name": "{{3.data[1].file_name}}",
      "file_path": "{{3.data[1].storage_path}}"
    }
  ],
  "settings": {
    "parser": "Docling Parser",
    "chunking_strategy": "Recursive Chunking",
    "chunk_size": 1000,
    "chunk_overlap": 200
  }
}

Module 6 — Sleep

Module 7 — HTTP: Check Stage

Module 8 — Router (Poll Loop)

• Route 1 (Still Processing): Filter {{7.data.status}} equals Processing — loop back to Sleep module using a Repeater with max iterations set to 20
• Route 2 (Done): Filter {{7.data.status}} does not equal Processing — proceed to notification

2. Slack Bot with RAG Chat¶

Build a Slack bot that answers questions using your Beyond Retrieval knowledge base.

graph LR
    A[Slack: Watch Messages] --> B[Filter: Is Question?]
    B --> C[HTTP: Create Conversation]
    C --> D[HTTP: Send RAG Message]
    D --> E[Router]
    E -->|Success| F[Slack: Reply in Thread]
    E -->|Failure| G[Slack: Reply with Error]

Module 1 — Slack: Watch New Messages

Module 2 — Filter

Filter out messages that should not trigger a RAG query:

Module 3 — HTTP: Create Conversation

Module 4 — HTTP: Send RAG Message

{
  "content": "{{1.text}}",
  "chat_mode": "rag",
  "strategy_id": "fusion",
  "persona": "professional",
  "language": "en"
}

Module 5 — Router

• Success route: {{4.success}} equals true
• Error route: fallback

Module 6 — Slack: Post Reply

3. Scheduled Health Monitoring with Email¶

Check all notebook health scores daily and send a summary email.

graph LR
    A[Schedule: Daily 8am] --> B[HTTP: List Notebooks]
    B --> C[Iterator]
    C --> D[HTTP: Health Check]
    D --> E[Array Aggregator]
    E --> F[Filter: Any Unhealthy?]
    F --> G[Email: Send Report]

Module 1 — Schedule

Module 2 — HTTP: List Notebooks

Module 3 — Iterator

This iterates over each notebook in the list.

Module 4 — HTTP: Health Check

Module 5 — Array Aggregator

Collect all health check results into a single array for processing.

Module 6 — Filter: Any Unhealthy?

Check if any notebook has a health score below 70:

Module 7 — Email: Send Report

Compose an HTML email with the health summary. Use Make.com's text aggregator or a template to format the results:

Subject: Beyond Retrieval Health Report — {{formatDate(now; "YYYY-MM-DD")}}

Notebooks with health score below 70:

{{#each 5.array}}
- {{this.notebook_id}}: Score {{this.data.health_score}}/100
  Duplicates: {{this.data.duplicate_count}} | Orphans: {{this.data.orphaned_count}}
{{/each}}

4. Form Submission to Auto-Answer¶

Accept a question via a webhook form, query the RAG pipeline, and return the answer.

graph LR
    A[Webhooks: Custom Webhook] --> B[HTTP: Create Conversation]
    B --> C[HTTP: Send RAG Message]
    C --> D[Router]
    D -->|Success| E[Webhook Response: Answer]
    D -->|Failure| F[Webhook Response: Error]

Module 1 — Webhooks: Custom Webhook

Expected request body:

{
  "question": "What is the return policy?",
  "notebook_id": "a1b2c3d4-...",
  "language": "en"
}

Module 2 — HTTP: Create Conversation

Module 3 — HTTP: Send RAG Message

{
  "content": "{{1.question}}",
  "chat_mode": "rag",
  "strategy_id": "fusion",
  "persona": "professional",
  "language": "{{ifempty(1.language; \"en\")}}"
}

Module 4 — Router

• Success: {{3.success}} equals true
• Failure: fallback

Module 5 — Webhook Response (Success)

{
  "answer": "{{3.data.assistant_message.content}}",
  "citations": {{3.data.assistant_message.citations}},
  "is_cached": {{3.data.assistant_message.run_metadata.is_cached}},
  "suggested_questions": {{3.data.assistant_message.run_metadata.suggested_questions}}
}

Module 6 — Webhook Response (Error)

Error Handling¶

Error Routes¶

Make.com supports error handler routes on every module. Right-click any module and select Add error handler to create a fallback path.

Common error handler modules:

Retry Logic¶

Configure automatic retries in scenario settings:

For individual HTTP modules, use a Break error handler with the Automatically complete execution option to retry failed operations:

1. Add a Break module as an error handler on the HTTP module.
2. Enable Automatically complete execution.
3. Set Number of attempts to 3.
4. Set Interval to 30 seconds.

Variable Mapping Patterns¶

Accessing Nested Response Data¶

Beyond Retrieval responses use a nested structure. Here are common mapping patterns:

Replace X with the module number in your scenario.

Conditional Values¶

Use Make.com's ifempty and if functions:

// Default language to English
{{ifempty(1.language; "en")}}

// Choose persona based on channel
{{if(1.channel = "C123SUPPORT"; "professional"; "funny")}}

Array Iteration¶

When processing multiple items (e.g., notebook list, document list), use the Iterator module to split arrays and the Array Aggregator to recombine results.

Tips and Best Practices¶

Quick Reference — Common API Calls¶