What does it do? 

The 1_FORGE – Rek.ai extension integrates the Rek.ai content recommendation service into your TYPO3 website. Rek.ai is a Swedish SaaS platform that analyses visitor behaviour in real time and serves personalised content recommendations — helping you increase page views, dwell time, and reader engagement without any tracking cookies.

The extension provides four complementary integration points:

1. Global script injection — the Rek.ai JavaScript is automatically added to every frontend page via a PageRenderer hook, so no TypoScript or manual template changes are required once it is configured. An optional Non CSS Version mode disables Rek.ai's built-in inline CSS.
2. Autocomplete — the Rek.ai autocomplete library can be loaded and initialised automatically. Three modes are available: disabled, default (selector-based, with generated initialisation script), and custom (editor-provided JavaScript block).
3. Recommendations content element — a dedicated backend content element (CType rekai_recommendations) lets editors place a personalised recommendations widget anywhere in the page layout. Editors have full control over the number of results, the render style, header text, and the scope of pages that Rek.ai considers as candidates — including selecting specific pages directly.
4. Questions and Answers content element — a second content element (CType rekai_qna) renders a Rek.ai Q&A widget. Editors can configure the number of results, the branch scope, tag filters, and link behaviour.

Screenshots 

Requirements 

TYPO3

Version 12.4 LTS – 13.4 LTS

PHP

8.1 or later

Rek.ai account

A valid Rek.ai account and a script URL provided by Rek.ai (e.g. https://static.rekai.se/xyz.js).

Credits 

Developed and maintained by 1_FORGE.

Feedback & Bug Reports 

Please use the issue tracker of the extension's source repository to report bugs or request features.

Installation via Composer (recommended) 

The extension is available on Packagist. Run the following command in your TYPO3 project root:

composer require one-forge/rek-ai

After installation, activate the extension and run the TYPO3 database upgrade wizard if prompted:

vendor/bin/typo3 extension:activate one_forge_rekai
vendor/bin/typo3 database:updateschema

Installation via Extension Manager (TER) 

1. Open Admin Tools > Extensions in the TYPO3 backend.
2. Switch to the Get Extensions tab.
3. Search for one_forge_rekai and click Import and Install.
4. Activate the extension using the toggle in the extension list.
5. Run Admin Tools > Maintenance > Analyze Database Structure to apply the new database columns.

Include the TypoScript template 

The extension ships a TypoScript setup file that registers the rekai_recommendations content element renderer. It is auto-imported via ExtensionManagementUtility::addTypoScriptSetup() in ext_localconf.php, so no manual template inclusion is required.

If you prefer to include it explicitly (e.g. in a site package), add the following to your TypoScript setup:

@import 'EXT:one_forge_rekai/Configuration/TypoScript/setup.typoscript'

Next steps 

After installation, proceed to Configuration to enter your Rek.ai script URL and enable script injection.

Backend Configuration Module 

The primary way to configure this extension is through the dedicated backend module located at Site > Rek.ai. It is accessible to administrators only.

Configuration is per TYPO3 site. When the TYPO3 installation contains more than one site, a site selector dropdown appears at the top of the module. Select the site you want to configure before making changes — each site stores its own independent set of values in config/sites/<identifier>/settings.yaml under the one_forge_rekai key.

The module is divided into two sections: Script Integration and Autocomplete.

<script src="https://static.rekai.se/xyz.js" defer></script>

<script src="https://static.rekai.se/xyz.js" data-allowinlinecss="false" defer></script>

Site Settings Storage 

All values configured in the backend module are stored per site in config/sites/<identifier>/settings.yaml under the one_forge_rekai key. The file is created automatically on first save if it does not already exist.

Example config/sites/my-site/settings.yaml:

one_forge_rekai:
  loadScripts: true
  scriptUrl: 'https://static.rekai.se/xyz.js'
  nonCssVersion: false
  autocompleteMode: 1
  autocompleteSelector: '#searchform-input'
  autocompleteOpenOnClick: true
  autocompleteUseCurrentLanguage: true
  autocompleteNumberOfResults: 5
  autocompleteCustomScript: ''

Each site in a multi-site TYPO3 installation maintains its own independent configuration file. Values are read and written by OneForgeRekAiServiceRekAiConfigurationService via TYPO3CMSCoreSiteSiteSettingsService and TYPO3CMSCoreSiteSiteSettingsFactory.

TypoScript Reference 

The extension auto-imports the following TypoScript setup, which registers both content element rendering chains:

tt_content.rekai_recommendations = FLUIDTEMPLATE
tt_content.rekai_recommendations {
    templateName = RekaiRecommendations

    templateRootPaths {
        10 = EXT:one_forge_rekai/Resources/Private/Templates/Content/
    }

    dataProcessing {
        10 = OneForge\RekAi\DataProcessing\RekaiSettingsProcessor
    }
}

tt_content.rekai_qna = FLUIDTEMPLATE
tt_content.rekai_qna {
    templateName = RekaiQna

    templateRootPaths {
        10 = EXT:one_forge_rekai/Resources/Private/Templates/Content/
    }

    dataProcessing {
        10 = OneForge\RekAi\DataProcessing\RekaiSettingsProcessor
    }
}

dataProcessing.10 (RekaiSettingsProcessor) passes the extension configuration array as the Fluid variable {rekaiSettings} to both templates. It also resolves any selected page UIDs to their URL slugs so they can be passed as data-subtree attributes.

<div class="rek-prediction"
     data-headertext="Discover more"
     data-nrofhits="5"
     data-renderstyle="pills">
</div>

<div class="rek-prediction"
     data-nrofhits="5"
     data-renderstyle="list"
     data-listcols="2"
     data-subtree="/news/,/blog/">
</div>

<div class="rek-prediction"
     data-entitytype="rekai-qna"
     data-nrofhits="10"
     data-userootpath="true">
</div>

The "Rek.ai Recommendations" Content Element 

The Rek.ai Recommendations content element (internal CType: rekai_recommendations) renders a personalised content recommendations widget. Add it to any page column using the standard TYPO3 content element wizard.

Content Element Tabs 

General (tab) 

The standard TYPO3 general tab. The Header field (if shown) is part of the default TYPO3 header palette and is independent of the Rek.ai widget header described below.

Display (tab) 

Show Header

Toggle (on by default). When enabled, the widget displays a header above the recommendations list.

Header Text

(only visible when Show Header is on) The text displayed as a header above the recommendations. Defaults to Discover more.

Number of Hits

How many recommendation links the widget should display. Accepts a value between 1 and 20. Default: 5.

Hit Title Max Length

Maximum number of characters rendered for each recommendation link title. Accepts a value between 1 and 99. Default: 20. Maps to the data-titlemaxlength attribute.

Render Style

Controls the visual layout of the recommendations:

Pills

Displays recommendations as pill-shaped badges (default).

List

Displays recommendations as a multi-column list. The number of columns is controlled by Number of Columns (see below).

Advanced

Uses Rek.ai's advanced rendering mode. Refer to the Rek.ai documentation for details.

Number of Columns

(only visible when Render Style is set to List ) Number of columns in the list layout. Accepts a value between 1 and 6. Default: 2.

Recommendation Source (tab) 

These settings control which pages Rek.ai considers as recommendation candidates.

Recommendation Source

Defines the scope of pages passed to Rek.ai:

Current page (default)

No explicit root path is set; Rek.ai uses its own default scope.

Use only subpages of the current page

Limits recommendations to the direct or indirect children of the current page (data-userootpath="true").

Use subpages from a specific level

Limits recommendations to subpages starting from a specific page tree level (data-userootpath="true" + data-rootpathlevel). The Root Path Level and Select Subtree Pages fields appear when this option is selected.

Root Path Level

(only visible when Recommendation Source is set to Use subpages from a specific level ) The tree level (1–10) from which subpages are used as the recommendation pool.

Select Subtree Pages

(only visible when Recommendation Source is set to Use subpages from a specific level ) Optional multi-page selector. When pages are selected, their URL slugs are passed to Rek.ai as a data-subtree attribute (comma-separated), further narrowing the subtree scope.

Exclude child nodes of the starting point

When enabled, only the pages directly at the root path level are included; their children are excluded.

Advanced (tab) 

Extra Attributes

Arbitrary HTML data attributes added verbatim to the <div class="rek-prediction"> element. Use this to pass custom configuration to the Rek.ai script that is not covered by the standard fields.

Example value: data-foo="bar" data-baz="qux"

Warning

The value of this field is output without HTML escaping (f:format.raw). Only enter trusted values here.

<div class="rek-prediction"
     data-headertext="You might also like"
     data-nrofhits="4"
     data-renderstyle="list"
     data-listcols="3"
     data-userootpath="true"
     data-rootpathlevel="2">
</div>

<div class="rek-prediction"
     data-nrofhits="5"
     data-renderstyle="pills"
     data-subtree="/news/,/blog/articles/">
</div>

The "Rek.ai Questions and Answers" Content Element 

The Rek.ai Questions and Answers content element (internal CType: rekai_qna) renders a Rek.ai Q&A widget that displays relevant questions and answers sourced from your content. Add it to any page column using the standard TYPO3 content element wizard.

<div class="rek-prediction"
     data-entitytype="rekai-qna"
     data-nrofhits="10"
     data-userootpath="true">
</div>

<div class="rek-prediction"
     data-entitytype="rekai-qna"
     data-subtree="/faq/,/support/"
     data-tags="returns,shipping">
</div>

Architecture Overview 

The extension follows standard TYPO3 12/13 patterns: PSR-4 autoloading, Symfony DI with autowiring, attribute-based backend controller registration, and Fluid templates.

Classes/
├── Controller/Backend/
│   └── ConfigurationController.php   # Backend module controller
├── DataProcessing/
│   └── RekaiSettingsProcessor.php    # Fluid data processor
├── Hook/
│   └── PageRendererHook.php          # PageRenderer pre-process hook
└── Service/
    └── RekAiConfigurationService.php # Read/write extension configuration

RekAiConfigurationService 

OneForgeRekAiServiceRekAiConfigurationService is the central service for reading and writing the extension configuration. Configuration is per site and stored in config/sites/<identifier>/settings.yaml. The service is available via dependency injection.

use OneForge\RekAi\Service\RekAiConfigurationService;
use TYPO3\CMS\Core\Site\Entity\Site;

// Via constructor injection (recommended)
public function __construct(
    private readonly RekAiConfigurationService $rekAiConfigService,
) {}

PageRendererHook 

OneForgeRekAiHookPageRendererHook is registered via ext_localconf.php as a render-preProcess hook on t3lib_pagerenderer:

$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']
    ['t3lib/class.t3lib_pagerenderer.php']['render-preProcess'][]
    = \OneForge\RekAi\Hook\PageRendererHook::class . '->addRekAiScript';

The hook's addRekAiScript() method:

1. Reads the current site from $GLOBALS['TYPO3_REQUEST']->getAttribute('site').
2. Returns early if the attribute is not a concrete Site instance (e.g. CLI or backend context).
3. Reads the configuration for that site via RekAiConfigurationService.
4. Returns early if loadScripts is disabled or scriptUrl is empty.

5. Otherwise calls PageRenderer::addHeaderData() with:

   <script src="https://static.rekai.se/xyz.js" defer></script>

   Copied!

The src attribute is escaped with htmlspecialchars().

RekaiSettingsProcessor 

OneForgeRekAiDataProcessingRekaiSettingsProcessor implements TYPO3CMSFrontendContentObjectDataProcessorInterface. It is configured in the TypoScript rendering chain for both tt_content.rekai_recommendations and tt_content.rekai_qna:

dataProcessing {
    10 = OneForge\RekAi\DataProcessing\RekaiSettingsProcessor
}

The processor reads the full extension configuration for the current site and assigns it as the Fluid variable {rekaiSettings}. Both frontend templates use {rekaiSettings.loadScripts} to guard their widget output. The processor also resolves any selected page UIDs in the tx_rekai_subtree_pages / tx_rekai_qna_subtree_pages group fields to URL slugs, storing the result in data.tx_rekai_subtree / data.tx_rekai_qna_subtree respectively.

ConfigurationController 

OneForgeRekAiControllerBackendConfigurationController handles both GET and POST requests for the backend module. It is registered with the #[AsBackendController] attribute and resolves through Symfony DI.

Site resolution — the active site is determined from the rekaiSite key in the POST body (hidden form field) or GET query parameter, falling back to the first site returned by SiteFinder::getAllSites(). URLs for site switching are built via BackendUriBuilder::buildUriFromRoute() so they survive TYPO3's backend routing.

GET – renders the form pre-populated with the configuration of the resolved site. When more than one TYPO3 site exists, a site selector dropdown is shown above the form.

POST – validates input (URL must be valid when loadScripts is checked), saves the configuration for the resolved site via RekAiConfigurationService::saveConfiguration(), queues a flash message, and redirects (PRG pattern) back to the module URL for the same site.

The controller uses ModuleTemplateFactory to create a ModuleTemplate and returns ModuleTemplate::renderResponse('Backend/Configuration/Index').

TCA & Database Schema 

The extension extends tt_content with the following columns:

rekai_recommendations

rekai_qna

Dependency Injection 

Configuration/Services.yaml enables autowiring and autoconfiguration for all classes under the OneForge\RekAi\ namespace. The backend controller is explicitly declared public: true so TYPO3's backend routing can resolve it from the container:

services:
  _defaults:
    autowire: true
    autoconfigure: true
    public: false

  OneForge\RekAi\:
    resource: '../Classes/*'

  OneForge\RekAi\Controller\Backend\ConfigurationController:
    public: true

  OneForge\RekAi\Hook\PageRendererHook:
    public: true

Extending the Extension 

tt_content.rekai_recommendations.templateRootPaths {
    20 = EXT:my_site_package/Resources/Private/Templates/Content/
}

tt_content.rekai_recommendations.dataProcessing {
    20 = Vendor\MyExtension\DataProcessing\MyProcessor
}

1.3.0 

Release date: 11.05.2026

Features

• TYPO3 14.x compatibility — the extension now supports TYPO3 14.x in addition to 12.4 and 13.4.

1.2.1 

Release date: 04.05.2026

Bug fixes

• Fixed a typo in the TCA column key for the Render Style field: it was registered as tx_rekai_recnderstyle instead of tx_rekai_renderstyle, which caused the field to be invisible in the backend form under the Display tab of the Rek.ai Recommendations content element.

1.2.0 

Release date: 29.04.2026

Features

• Per-site configuration — extension settings are now stored independently for each TYPO3 site in config/sites/<identifier>/settings.yaml under the one_forge_rekai key. Previously all sites shared a single global configuration in config/system/settings.php.
• Site selector dropdown in the backend module: when a TYPO3 installation contains more than one site, a selector appears above the form so administrators can configure each site individually without leaving the module.

Breaking changes

• All public methods of RekAiConfigurationService now require a TYPO3CMSCoreSiteEntitySite argument. Custom code calling the service directly must be updated to pass the relevant site object.

1.1.0 

Release date: 08.04.2026

Features

• Backend module — Non CSS Version toggle: adds data-allowinlinecss="false" to the injected <script> tag, allowing sites to provide their own styling for Rek.ai widgets instead of using the built-in inline CSS.
• Autocomplete integration in the backend module: three modes are available — disabled, default selector-based (with generated initialisation script and live preview), and custom (editor-provided JavaScript block). Supports configurable selector, open-on-click behaviour, current-language filtering, and number of results.
• New ``rekai_qna`` content element (Rek.ai Questions and Answers): renders a <div class="rek-prediction" data-entitytype="rekai-qna"> widget. Supports branch-mode scoping (none / current branch / specific pages / current page only), tag filtering, and configurable link and highlight behaviour.
• ``rekai_recommendations`` content element — new Use specific pages source mode: editors can select individual pages directly as the recommendation source. Selected page UIDs are resolved to URL slugs and passed as data-subtree to the Rek.ai script.

1.0.0 

Release date: 23.03.2026

Initial release.

Features

• Backend configuration module under Site > Rek.ai to manage the Rek.ai script URL and the global script injection toggle.
• PageRendererHook that injects the Rek.ai <script defer> tag into every frontend page when enabled.
• rekai_recommendations content element with configurable display options (render style, number of hits, header text) and recommendation source scoping (current page, subpages, page tree level).
• RekAiConfigurationService for reading and writing extension configuration.
• RekaiSettingsProcessor data processor for passing extension settings to Fluid templates.
• Compatible with TYPO3 12.0–13.x and PHP 8.1+.