PHP CMS Framework

Build an AI-Driven personalisation engine in Joomla using User Behaviour data

noreply@blogger.com (PHP CMS Frameworks) — Sun, 26 Apr 2026 13:31:00 +0000

Most Joomla sites serve the same content to every registered user regardless of what they have read before, what they searched for, or how long they spent on specific topics. A user who has read six articles about Joomla security gets the same homepage recommendations as someone who only reads performance tuning content. That is a missed opportunity every single time they log in.

Personalisation is not a new idea but it has historically required either expensive third-party platforms or a data science team to implement properly. What has changed is that OpenAI's embedding and completion APIs make it possible to build a genuinely useful personalisation engine inside your existing Joomla installation without either of those things.

What we are building here is a system that tracks what registered users click on, which articles they read, how long they spend reading, and what they search for. It uses that behaviour data to build an interest profile per user, then uses OpenAI embeddings to find articles that match that profile semantically, not just by category tag. The result is a recommendations module that gets more accurate the more a user engages with the site.

What you need: Joomla 4 or 5, PHP 8.1+, Composer, MySQL, and an OpenAI API key.

How the system works End to End

Before writing any code, the architecture is worth understanding clearly. There are three distinct parts to this system and keeping them separate makes the whole thing easier to build and maintain.

Part 1: Behaviour Tracking
        User reads an article, searches, or clicks a link
                ↓
        JavaScript sends event data to a Joomla plugin endpoint
                ↓
        Event stored in user_behaviour_events table

Part 2: Profile Building (runs on cron every hour)
        Fetch recent behaviour events per user
                ↓
        Build a text summary of user interests from event data
                ↓
        Send summary to OpenAI Embeddings API
                ↓
        Store interest profile vector in user_interest_profiles table

Part 3: Recommendations (runs on module render)
        Load current user's interest profile vector
                ↓
        Compare against pre-computed article embedding vectors
                ↓
        Return top N articles by cosine similarity
                ↓
        Render as a recommendations module on any page

The profile building step is the key insight here. Rather than trying to match individual behaviour events to articles directly, we build a text summary of each user's interests from their behaviour data, embed that summary as a vector, and then find articles that are semantically close to it. This means a user who reads articles about "Joomla template overrides" and "child theme development" will get recommendations about "Joomla layout XML" even if that exact phrase never appeared in their behaviour history.

Database Tables

We need three tables. One for raw behaviour events, one for computed user interest profiles, and one for pre-computed article embeddings. Run these in your Joomla database:

CREATE TABLE `#__user_behaviour_events` (
    `id`           INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    `user_id`      INT UNSIGNED NOT NULL,
    `event_type`   ENUM('view','click','search','time_on_page') NOT NULL,
    `article_id`   INT UNSIGNED NULL,
    `search_query` VARCHAR(500) NULL,
    `duration_seconds` INT UNSIGNED NULL,
    `metadata`     JSON NULL,
    `created_at`   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    INDEX `idx_user_events` (`user_id`, `created_at`),
    INDEX `idx_article_events` (`article_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `#__user_interest_profiles` (
    `user_id`      INT UNSIGNED PRIMARY KEY,
    `interest_summary` TEXT NOT NULL,
    `embedding`    JSON NOT NULL,
    `events_count` INT UNSIGNED NOT NULL DEFAULT 0,
    `updated_at`   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `#__article_embeddings` (
    `article_id`   INT UNSIGNED PRIMARY KEY,
    `embedding`    JSON NOT NULL,
    `indexed_at`   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

MySQL does not have a native vector type so we are storing embeddings as JSON arrays. For sites with large article catalogues, over a few thousand articles, consider migrating to PostgreSQL with pgvector for proper vector indexing and faster similarity queries. For most Joomla sites MySQL with JSON embeddings works fine.

Part 1: Behaviour Tracking Plugin

Create a Joomla system plugin that handles two things: serving a lightweight JavaScript tracker, and receiving the behaviour events that tracker sends back.

Module structure at plugins/system/behaviourtracker/:

plugins/system/behaviourtracker/
    behaviourtracker.php
    behaviourtracker.xml
    src/
        Extension/
            BehaviourTracker.php
    media/
        js/
            tracker.js

The main plugin class at src/Extension/BehaviourTracker.php:

<?php

namespace Joomla\Plugin\System\BehaviourTracker\Extension;

use Joomla\CMS\Plugin\CMSPlugin;
use Joomla\CMS\Factory;
use Joomla\CMS\Uri\Uri;

class BehaviourTracker extends CMSPlugin
{
    public function onAfterDispatch(): void
    {
        $app  = Factory::getApplication();
        $user = Factory::getUser();

        // Only track logged-in users on site pages
        if ($user->guest || $app->isClient('administrator')) {
            return;
        }

        $input  = $app->getInput();
        $option = $input->getCmd('option');
        $view   = $input->getCmd('view');

        // Track article views automatically on the server side
        if ($option === 'com_content' && $view === 'article') {
            $articleId = $input->getInt('id');
            if ($articleId) {
                $this->recordEvent($user->id, 'view', $articleId);
            }
        }

        // Inject the JavaScript tracker on all frontend pages
        $doc     = $app->getDocument();
        $baseUrl = Uri::root();

        $doc->addScriptOptions('behaviourTracker', [
            'userId'   => $user->id,
            'endpoint' => $baseUrl . 'index.php?option=com_ajax&group=system&plugin=behaviourtracker&format=json',
            'articleId'=> ($option === 'com_content' && $view === 'article')
                          ? $input->getInt('id') : null,
        ]);

        $doc->addScript(Uri::root() . 'media/plg_system_behaviourtracker/js/tracker.js', [], ['defer' => true]);
    }

    public function onAjaxBehaviourtracker(): void
    {
        $app  = Factory::getApplication();
        $user = Factory::getUser();

        if ($user->guest) {
            echo json_encode(['status' => 'ignored']);
            $app->close();
        }

        $input     = $app->getInput()->json;
        $eventType = $input->getString('event_type');
        $articleId = $input->getInt('article_id', 0);
        $query     = $input->getString('search_query', '');
        $duration  = $input->getInt('duration_seconds', 0);

        $allowed = ['click', 'search', 'time_on_page'];

        if (!in_array($eventType, $allowed)) {
            echo json_encode(['status' => 'invalid']);
            $app->close();
        }

        $this->recordEvent(
            $user->id,
            $eventType,
            $articleId ?: null,
            $query ?: null,
            $duration ?: null
        );

        echo json_encode(['status' => 'ok']);
        $app->close();
    }

    private function recordEvent(
        int     $userId,
        string  $eventType,
        ?int    $articleId   = null,
        ?string $searchQuery = null,
        ?int    $duration    = null
    ): void {
        $db = Factory::getDbo();

        $row = (object)[
            'user_id'          => $userId,
            'event_type'       => $eventType,
            'article_id'       => $articleId,
            'search_query'     => $searchQuery,
            'duration_seconds' => $duration,
            'created_at'       => date('Y-m-d H:i:s'),
        ];

        $db->insertObject('#__user_behaviour_events', $row);
    }
}

Now the JavaScript tracker at media/js/tracker.js:

(function () {
    const config = Joomla.getOptions('behaviourTracker');

    if (!config || !config.userId) return;

    const endpoint = config.endpoint;
    const articleId = config.articleId;

    function send(payload) {
        navigator.sendBeacon
            ? navigator.sendBeacon(endpoint, JSON.stringify(payload))
            : fetch(endpoint, { method: 'POST', body: JSON.stringify(payload),
                                keepalive: true });
    }

    // Track time on page for article views
    if (articleId) {
        const startTime = Date.now();

        window.addEventListener('beforeunload', function () {
            const duration = Math.round((Date.now() - startTime) / 1000);

            // Only record if they spent more than 10 seconds
            if (duration > 10) {
                send({
                    event_type:       'time_on_page',
                    article_id:       articleId,
                    duration_seconds: duration,
                });
            }
        });
    }

    // Track internal link clicks to articles
    document.addEventListener('click', function (e) {
        const link = e.target.closest('a[href]');
        if (!link) return;

        const href = link.getAttribute('href');
        const match = href.match(/[?&]id=(\d+)/);

        if (match && href.includes('com_content')) {
            send({
                event_type: 'click',
                article_id: parseInt(match[1]),
            });
        }
    });

    // Track search queries
    const searchForm = document.querySelector('form[action*="com_search"], form[action*="com_finder"]');

    if (searchForm) {
        searchForm.addEventListener('submit', function () {
            const input = searchForm.querySelector('input[type="text"], input[name="q"], input[name="searchword"]');

            if (input && input.value.trim().length > 2) {
                send({
                    event_type:   'search',
                    search_query: input.value.trim(),
                });
            }
        });
    }
})();

Using navigator.sendBeacon for the time-on-page event is important. When a user navigates away, fetch requests get cancelled before they complete. sendBeacon is designed specifically for this situation and guarantees the request goes through even as the page unloads.

Part 2: Interest Profile Builder

This is the part that makes the recommendations smart rather than just "articles in the same category." Create this as a Joomla CLI task that runs on cron every hour.

Create components/com_personalisation/src/Service/ProfileBuilder.php:

<?php

namespace Joomla\Component\Personalisation\Site\Service;

use Joomla\CMS\Factory;
use OpenAI;

class ProfileBuilder
{
    private $openai;
    private int $lookbackDays = 30;
    private int $minEvents    = 3;

    public function __construct()
    {
        $params       = \JComponentHelper::getParams('com_personalisation');
        $this->openai = OpenAI::client($params->get('openai_api_key'));
    }

    public function buildForAllUsers(): array
    {
        $db = Factory::getDbo();

        // Find users who have behaviour events and need profile updates
        $query = $db->getQuery(true)
            ->select('DISTINCT e.user_id')
            ->from($db->quoteName('#__user_behaviour_events', 'e'))
            ->where($db->quoteName('e.created_at') . ' > ' .
                    $db->quote(date('Y-m-d H:i:s', strtotime("-{$this->lookbackDays} days"))))
            ->group($db->quoteName('e.user_id'))
            ->having('COUNT(*) >= ' . $this->minEvents);

        $userIds = $db->setQuery($query)->loadColumn();

        $built  = 0;
        $errors = 0;

        foreach ($userIds as $userId) {
            try {
                $this->buildForUser((int) $userId);
                $built++;
            } catch (\Exception $e) {
                $errors++;
                \JLog::add(
                    "Profile build failed for user {$userId}: " . $e->getMessage(),
                    \JLog::ERROR,
                    'com_personalisation'
                );
            }

            // Avoid hitting OpenAI rate limits
            usleep(100000);
        }

        return ['built' => $built, 'errors' => $errors];
    }

    public function buildForUser(int $userId): void
    {
        $db     = Factory::getDbo();
        $events = $this->fetchEvents($userId);

        if (empty($events)) {
            return;
        }

        // Build interest summary from behaviour events
        $summary = $this->buildInterestSummary($userId, $events);

        // Get embedding for the interest summary
        $response  = $this->openai->embeddings()->create([
            'model' => 'text-embedding-3-small',
            'input' => $summary,
        ]);

        $embedding = $response->embeddings[0]->embedding;

        // Upsert the user interest profile
        $existing = $db->setQuery(
            $db->getQuery(true)
                ->select('user_id')
                ->from('#__user_interest_profiles')
                ->where('user_id = ' . (int) $userId)
        )->loadResult();

        $row = (object)[
            'user_id'          => $userId,
            'interest_summary' => $summary,
            'embedding'        => json_encode($embedding),
            'events_count'     => count($events),
            'updated_at'       => date('Y-m-d H:i:s'),
        ];

        $existing
            ? $db->updateObject('#__user_interest_profiles', $row, 'user_id')
            : $db->insertObject('#__user_interest_profiles', $row);
    }

    private function fetchEvents(int $userId): array
    {
        $db    = Factory::getDbo();
        $since = date('Y-m-d H:i:s', strtotime("-{$this->lookbackDays} days"));

        $query = $db->getQuery(true)
            ->select([
                'e.event_type',
                'e.article_id',
                'e.search_query',
                'e.duration_seconds',
                'a.title AS article_title',
                'a.catid',
                'c.title AS category_title',
            ])
            ->from($db->quoteName('#__user_behaviour_events', 'e'))
            ->leftJoin($db->quoteName('#__content', 'a') . ' ON a.id = e.article_id')
            ->leftJoin($db->quoteName('#__categories', 'c') . ' ON c.id = a.catid')
            ->where('e.user_id = ' . (int) $userId)
            ->where('e.created_at > ' . $db->quote($since))
            ->order('e.created_at DESC')
            ->setLimit(200);

        return $db->setQuery($query)->loadAssocList();
    }

    private function buildInterestSummary(int $userId, array $events): string
    {
        $viewedTitles    = [];
        $searchQueries   = [];
        $categories      = [];
        $longReads       = [];

        foreach ($events as $event) {
            if ($event['article_title']) {
                $viewedTitles[] = $event['article_title'];
            }

            if ($event['category_title']) {
                $categories[] = $event['category_title'];
            }

            if ($event['search_query']) {
                $searchQueries[] = $event['search_query'];
            }

            // Articles read for more than 90 seconds indicate strong interest
            if ($event['duration_seconds'] > 90 && $event['article_title']) {
                $longReads[] = $event['article_title'];
            }
        }

        // Deduplicate and limit to avoid overly long summaries
        $viewedTitles  = array_unique(array_slice($viewedTitles, 0, 20));
        $searchQueries = array_unique(array_slice($searchQueries, 0, 10));
        $categories    = array_values(array_unique($categories));
        $longReads     = array_unique($longReads);

        // Count category frequency to identify dominant interests
        $catCounts = array_count_values(array_column($events, 'category_title'));
        arsort($catCounts);
        $topCategories = array_keys(array_slice($catCounts, 0, 5, true));

        $parts = [];

        if (!empty($topCategories)) {
            $parts[] = "Primary interests: " . implode(', ', $topCategories) . ".";
        }

        if (!empty($searchQueries)) {
            $parts[] = "Searched for: " . implode(', ', $searchQueries) . ".";
        }

        if (!empty($longReads)) {
            $parts[] = "Read thoroughly: " . implode(', ', $longReads) . ".";
        }

        if (!empty($viewedTitles)) {
            $parts[] = "Also viewed: " . implode(', ', $viewedTitles) . ".";
        }

        return implode(' ', $parts);
    }
}

The interest summary construction is worth explaining. We weight long reads (over 90 seconds) separately because time spent reading is a stronger signal of genuine interest than a quick click. Category frequency tells us which topics dominate a user's browsing. Search queries tell us what they were actively looking for, not just passively browsing. Combining these three signals produces a richer interest summary than article titles alone.

Part 3: Article Indexer

Before we can recommend articles, we need embeddings for each article. This service indexes your Joomla content into the article embeddings table.

Create components/com_personalisation/src/Service/ArticleIndexer.php:

<?php

namespace Joomla\Component\Personalisation\Site\Service;

use Joomla\CMS\Factory;
use OpenAI;

class ArticleIndexer
{
    private $openai;
    private int $batchSize = 20;

    public function __construct()
    {
        $params       = \JComponentHelper::getParams('com_personalisation');
        $this->openai = OpenAI::client($params->get('openai_api_key'));
    }

    public function indexAll(bool $forceReindex = false): array
    {
        $db = Factory::getDbo();

        $query = $db->getQuery(true)
            ->select(['a.id', 'a.title', 'a.introtext', 'a.fulltext', 'c.title AS category'])
            ->from($db->quoteName('#__content', 'a'))
            ->leftJoin($db->quoteName('#__categories', 'c') . ' ON c.id = a.catid')
            ->where('a.state = 1');

        if (!$forceReindex) {
            // Only index articles without existing embeddings
            $query->leftJoin($db->quoteName('#__article_embeddings', 'ae') . ' ON ae.article_id = a.id')
                  ->where('ae.article_id IS NULL');
        }

        $articles = $db->setQuery($query)->loadObjectList();

        if (empty($articles)) {
            return ['indexed' => 0, 'skipped' => 0];
        }

        $indexed = 0;
        $errors  = 0;
        $batches = array_chunk($articles, $this->batchSize);

        foreach ($batches as $batch) {
            $texts = array_map(function ($article) {
                $body = strip_tags($article->introtext . ' ' . $article->fulltext);
                $body = preg_replace('/\s+/', ' ', $body);
                $body = substr(trim($body), 0, 2000);
                return $article->category . ': ' . $article->title . '. ' . $body;
            }, $batch);

            try {
                $response = $this->openai->embeddings()->create([
                    'model' => 'text-embedding-3-small',
                    'input' => $texts,
                ]);

                foreach ($batch as $i => $article) {
                    $embedding = $response->embeddings[$i]->embedding ?? null;

                    if (!$embedding) {
                        $errors++;
                        continue;
                    }

                    $this->upsertEmbedding($article->id, $embedding);
                    $indexed++;
                }

                usleep(200000);

            } catch (\Exception $e) {
                $errors += count($batch);
                \JLog::add('Article indexing error: ' . $e->getMessage(), \JLog::ERROR, 'com_personalisation');
            }
        }

        return ['indexed' => $indexed, 'errors' => $errors];
    }

    private function upsertEmbedding(int $articleId, array $embedding): void
    {
        $db = Factory::getDbo();

        $existing = $db->setQuery(
            $db->getQuery(true)
                ->select('article_id')
                ->from('#__article_embeddings')
                ->where('article_id = ' . $articleId)
        )->loadResult();

        $row = (object)[
            'article_id'  => $articleId,
            'embedding'   => json_encode($embedding),
            'indexed_at'  => date('Y-m-d H:i:s'),
        ];

        $existing
            ? $db->updateObject('#__article_embeddings', $row, 'article_id')
            : $db->insertObject('#__article_embeddings', $row);
    }
}

Notice the article text is prefixed with its category title before embedding. "Joomla Performance: Why your Joomla site is slow and how to fix it" produces a more accurate embedding than the title alone because the category provides context that helps distinguish articles on similar topics across different subject areas.

Part 4: The Recommendation Engine

Create components/com_personalisation/src/Service/RecommendationEngine.php:

<?php

namespace Joomla\Component\Personalisation\Site\Service;

use Joomla\CMS\Factory;

class RecommendationEngine
{
    private float $similarityThreshold = 0.70;

    public function getRecommendations(int $userId, int $limit = 5): array
    {
        $db = Factory::getDbo();

        // Load the user's interest profile
        $profile = $db->setQuery(
            $db->getQuery(true)
                ->select(['embedding', 'events_count'])
                ->from('#__user_interest_profiles')
                ->where('user_id = ' . $userId)
        )->loadObject();

        if (!$profile) {
            // No profile yet, return popular articles as fallback
            return $this->getPopularArticles($limit);
        }

        $userVector = json_decode($profile->embedding, true);

        if (empty($userVector)) {
            return $this->getPopularArticles($limit);
        }

        // Load all article embeddings
        $articles = $db->setQuery(
            $db->getQuery(true)
                ->select(['ae.article_id', 'ae.embedding', 'a.title', 'a.alias',
                           'a.catid', 'a.introtext', 'a.created', 'a.hits',
                           'c.title AS category', 'c.alias AS cat_alias'])
                ->from($db->quoteName('#__article_embeddings', 'ae'))
                ->join('INNER', $db->quoteName('#__content', 'a') . ' ON a.id = ae.article_id')
                ->join('LEFT', $db->quoteName('#__categories', 'c') . ' ON c.id = a.catid')
                ->where('a.state = 1')
        )->loadObjectList();

        // Get articles the user has already read so we don't recommend them again
        $readArticleIds = $db->setQuery(
            $db->getQuery(true)
                ->select('DISTINCT article_id')
                ->from('#__user_behaviour_events')
                ->where('user_id = ' . $userId)
                ->where('article_id IS NOT NULL')
                ->where("event_type IN ('view', 'click')")
        )->loadColumn();

        $readSet = array_flip($readArticleIds);

        // Score each article by cosine similarity to user interest vector
        $scored = [];

        foreach ($articles as $article) {
            // Skip already-read articles
            if (isset($readSet[$article->article_id])) {
                continue;
            }

            $articleVector = json_decode($article->embedding, true);

            if (empty($articleVector)) {
                continue;
            }

            $similarity = $this->cosineSimilarity($userVector, $articleVector);

            if ($similarity >= $this->similarityThreshold) {
                $scored[] = [
                    'article_id' => $article->article_id,
                    'title'      => $article->title,
                    'alias'      => $article->alias,
                    'category'   => $article->category,
                    'cat_alias'  => $article->cat_alias,
                    'introtext'  => strip_tags($article->introtext),
                    'created'    => $article->created,
                    'hits'       => $article->hits,
                    'similarity' => $similarity,
                ];
            }
        }

        // Sort by similarity score, highest first
        usort($scored, fn($a, $b) => $b['similarity'] <=> $a['similarity']);

        return array_slice($scored, 0, $limit);
    }

    private function cosineSimilarity(array $a, array $b): float
    {
        $dot  = 0.0;
        $magA = 0.0;
        $magB = 0.0;

        $len = min(count($a), count($b));

        for ($i = 0; $i < $len; $i++) {
            $dot  += $a[$i] * $b[$i];
            $magA += $a[$i] ** 2;
            $magB += $b[$i] ** 2;
        }

        $magA = sqrt($magA);
        $magB = sqrt($magB);

        return ($magA * $magB) > 0 ? $dot / ($magA * $magB) : 0.0;
    }

    private function getPopularArticles(int $limit): array
    {
        $db = Factory::getDbo();

        return $db->setQuery(
            $db->getQuery(true)
                ->select(['a.id AS article_id', 'a.title', 'a.alias',
                           'a.introtext', 'a.created', 'a.hits',
                           'c.title AS category', 'c.alias AS cat_alias'])
                ->from($db->quoteName('#__content', 'a'))
                ->leftJoin($db->quoteName('#__categories', 'c') . ' ON c.id = a.catid')
                ->where('a.state = 1')
                ->order('a.hits DESC')
                ->setLimit($limit)
        )->loadAssocList();
    }
}

The fallback to popular articles for users without a profile yet is important. A new registered user has no behaviour history, so returning nothing or an error is a bad experience. Popular articles are a reasonable default until enough behaviour data accumulates, which typically takes two to three sessions.

Excluding already-read articles from recommendations is something a lot of personalisation implementations skip. There is nothing more frustrating for a user than being recommended an article they read last week. The read set lookup adds minimal overhead and makes the recommendations feel genuinely useful.

Part 5: The Recommendations Module

Create a Joomla module that renders the recommendations anywhere on the site. Module structure at modules/mod_personalised_recommendations/:

modules/mod_personalised_recommendations/
    mod_personalised_recommendations.php
    mod_personalised_recommendations.xml
    tmpl/
        default.php

The main module file mod_personalised_recommendations.php:

<?php

defined('_JEXEC') or die;

use Joomla\CMS\Factory;
use Joomla\Component\Personalisation\Site\Service\RecommendationEngine;

$user = Factory::getUser();

if ($user->guest) {
    return;
}

$limit  = $params->get('article_count', 5);
$engine = new RecommendationEngine();

try {
    $recommendations = $engine->getRecommendations($user->id, $limit);
} catch (\Exception $e) {
    \JLog::add('Recommendations module error: ' . $e->getMessage(), \JLog::ERROR, 'mod_personalised_recommendations');
    $recommendations = [];
}

if (empty($recommendations)) {
    return;
}

require JModuleHelper::getLayoutPath('mod_personalised_recommendations', $params->get('layout', 'default'));

The module template at tmpl/default.php:

<?php defined('_JEXEC') or die; ?>

<div class="mod-personalised-recommendations">

    <h3><?php echo htmlspecialchars($params->get('header_text', 'Recommended for You')); ?></h3>

    <ul>
        <?php foreach ($recommendations as $item) : ?>
            <li>
                <a href="<?php echo JRoute::_(
                    'index.php?option=com_content&view=article&id=' . $item['article_id']
                    . '&catid=' . ($item['catid'] ?? '')
                ); ?>">
                    <?php echo htmlspecialchars($item['title']); ?>
                </a>

                <?php if ($params->get('show_category', 1) && !empty($item['category'])) : ?>
                    <span class="article-category">
                        <?php echo htmlspecialchars($item['category']); ?>
                    </span>
                <?php endif; ?>

                <?php if ($params->get('show_intro', 1) && !empty($item['introtext'])) : ?>
                    <p><?php echo htmlspecialchars(substr(strip_tags($item['introtext']), 0, 120)) . '...'; ?></p>
                <?php endif; ?>
            </li>
        <?php endforeach; ?>
    </ul>

</div>

Wiring It All Together With Cron

The profile builder needs to run on a schedule. Create a Joomla CLI script at cli/personalisation_cron.php:

<?php

define('_JEXEC', 1);
define('JPATH_BASE', dirname(__DIR__));

require_once JPATH_BASE . '/includes/defines.php';
require_once JPATH_BASE . '/includes/framework.php';

use Joomla\CMS\Factory;
use Joomla\Component\Personalisation\Site\Service\ProfileBuilder;
use Joomla\Component\Personalisation\Site\Service\ArticleIndexer;

$app = Factory::getApplication('cli');

$task = $argv[1] ?? 'profiles';

switch ($task) {
    case 'index':
        $indexer = new ArticleIndexer();
        $result  = $indexer->indexAll();
        echo "Indexed: {$result['indexed']}, Errors: {$result['errors']}\n";
        break;

    case 'profiles':
    default:
        $builder = new ProfileBuilder();
        $result  = $builder->buildForAllUsers();
        echo "Profiles built: {$result['built']}, Errors: {$result['errors']}\n";
        break;
}

Add these to your server crontab:

# Rebuild user interest profiles every hour
0 * * * * php /path/to/joomla/cli/personalisation_cron.php profiles >> /var/log/joomla_personalisation.log 2>&1

# Index new articles every 6 hours
0 */6 * * * php /path/to/joomla/cli/personalisation_cron.php index >> /var/log/joomla_personalisation.log 2>&1

Run the article indexer manually first before anything else:

php /path/to/joomla/cli/personalisation_cron.php index

This builds embeddings for all your existing articles. Depending on how many articles you have, this might take a few minutes and cost a small amount in OpenAI API tokens. For 500 articles it typically costs less than $0.10 using text-embedding-3-small.

What the Recommendations Look Like in Practice

Here is a realistic example of what the system produces after a user has been active for a few sessions. The user has read articles about Joomla template development, searched for "override layout XML", and spent over two minutes reading an article about Joomla child templates.

Their interest summary built by the profile builder:

Primary interests: Joomla Development, Joomla Theming.
Searched for: override layout XML, Joomla template child.
Read thoroughly: How to Create a Child Template in Joomla 5.
Also viewed: Joomla Template Overrides Explained, Understanding Joomla Layout XML,
             Joomla Module Chrome Types, Adding Custom CSS to a Joomla Template.

Top recommendations returned by the engine (articles they have not read yet):

[
  {
    "title": "Joomla 5 Template Positions: A Complete Guide",
    "category": "Joomla Development",
    "similarity": 0.912
  },
  {
    "title": "How to Override Joomla Core Templates Without Hacking Core",
    "category": "Joomla Development",
    "similarity": 0.887
  },
  {
    "title": "Using Bootstrap 5 Effectively in Custom Joomla Templates",
    "category": "Joomla Theming",
    "similarity": 0.871
  },
  {
    "title": "Joomla Module Assignment by Menu Item and User Group",
    "category": "Joomla Development",
    "similarity": 0.843
  },
  {
    "title": "Debugging Joomla Layout Issues with the Developer Toolbar",
    "category": "Joomla Development",
    "similarity": 0.831
  }
]

All five are relevant, none are articles the user has already read, and the recommendations are semantically accurate even though the user never used the exact phrase "template positions" or "Bootstrap" in their search queries. That is the embedding similarity working correctly.

A Few Things Worth Knowing Before You Deploy

The cosine similarity calculation in PHP is fine for article catalogues up to a few thousand articles. Once you get beyond that, the in-memory comparison of every article embedding against every user profile starts to add up. At that scale, moving the article embeddings to PostgreSQL with pgvector and running the similarity query in the database will keep response times fast.

Privacy is worth thinking about carefully before deploying behaviour tracking. Depending on your jurisdiction, tracking logged-in user behaviour may require disclosure in your privacy policy and potentially explicit consent. At minimum, update your privacy policy to mention that behaviour data is collected to improve content recommendations. For sites with European users, review GDPR requirements around behavioural profiling before going live.

The 30-day lookback window in the profile builder is a reasonable default but worth tuning for your site. On a site where users visit daily, 30 days captures good signal. On a site where users visit monthly, a 90-day window gives more data to work with. Adjust the $lookbackDays property in ProfileBuilder to match your site's typical visit cadence.

Finally, add a simple feedback mechanism if you can. Even a small thumbs up or thumbs down on recommended articles gives you data to validate whether the recommendations are actually landing well with your users. If most users ignore or actively dismiss recommendations, that tells you something about either the similarity threshold, the quality of your interest summaries, or the article content itself. Without that feedback loop, you are flying blind on whether the engine is actually helping.

Magento 2 - tips and tricks every Developer should know

noreply@blogger.com (PHP CMS Frameworks) — Tue, 07 Apr 2026 04:18:00 +0000

Magento 2 has a reputation for being complicated, and honestly that reputation is earned. The learning curve is steep, the documentation has gaps, and some of its architectural decisions only make sense once you have been burned by the alternative. I have been working with Magento 2 since its early releases and the tips in this post come directly from real projects, real mistakes, and things I wish someone had told me before I spent hours figuring them out the hard way.

This is not a list of things you will find in the official documentation. These are the practical things that make daily Magento 2 development faster, less frustrating, and more maintainable.

Development Workflow Tips

1. Always work in developer mode during development

This sounds obvious but I have seen teams develop in default mode and wonder why their template changes are not showing up. In developer mode, Magento disables most caching, enables full error reporting, and processes frontend assets on the fly. Switch modes from the command line:

php bin/magento deploy:mode:set developer

The flip side is that production mode compiles and minifies everything, which is why you must run the full deployment commands before pushing to production. Never deploy to production in developer mode. It is slower and exposes internal errors to visitors.

2. Know your cache types and clear only what you need

Running php bin/magento cache:flush clears everything and takes time. In most cases during development you only need to clear specific cache types. Clearing just the config cache after a config change, or just the layout cache after a layout XML change, is significantly faster.

# Clear only config cache
php bin/magento cache:clean config

# Clear layout and block cache after layout changes
php bin/magento cache:clean layout block_html

# Clear full page cache after template changes
php bin/magento cache:clean full_page

# See all cache types and their status
php bin/magento cache:status

Learn which cache type corresponds to which kind of change. It will save you minutes every time you test something.

3. Use n98-magerun2 for everything the CLI does not cover

n98-magerun2 is the Swiss Army knife for Magento 2 development. It extends Magento's CLI with hundreds of useful commands for database management, admin user creation, module management, and much more.

# Install globally
composer global require n98/magerun2

# Create an admin user without going through the UI
n98-magerun2 admin:user:create --username=devadmin --email=dev@example.com \
    --password=Dev@12345 --firstname=Dev --lastname=Admin

# Run a database query directly
n98-magerun2 db:query "SELECT * FROM admin_user"

# Open a MySQL console connected to Magento's database
n98-magerun2 db:console

# Show all configuration values for a path
n98-magerun2 config:store:get catalog/search/*

The db:console command alone is worth installing it for. No more hunting for database credentials in env.php every time you need to run a query.

4. Setup Xdebug properly

Too many Magento developers rely on var_dump and log files for debugging. Xdebug with step-through debugging changes how you work entirely. You can inspect the full call stack, watch variable values change in real time, and understand exactly what Magento is doing at any point in its request cycle.

The most common Xdebug configuration issue with Magento is the request timeout. Set a generous timeout in your php.ini because Magento's bootstrap takes longer than a typical PHP application and Xdebug adds overhead:

xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_host=host.docker.internal  ; if using Docker
xdebug.client_port=9003
xdebug.max_execution_time=0  ; disable timeout during debug sessions

5. Use the Magento 2 console to run cron manually

Waiting for Magento's cron to run on its schedule during development is painful. You can trigger specific cron groups manually:

# Run all cron jobs
php bin/magento cron:run

# Run a specific cron group
php bin/magento cron:run --group=index

# Check cron schedule
php bin/magento cron:schedule

If something is not updating after you expect it to, a manual cron run is often the answer.

Performance Tips

6. Enable Redis for Cache and Session Storage

File-based cache storage is fine for development but it will not scale in production. Redis handles Magento's cache and session storage significantly better, especially under concurrent load. Configure it in app/etc/env.php:

'cache' => [
    'frontend' => [
        'default' => [
            'backend' => 'Magento\\Framework\\Cache\\Backend\\Redis',
            'backend_options' => [
                'server'   => '127.0.0.1',
                'port'     => '6379',
                'database' => '0',
                'password' => '',
            ],
        ],
        'page_cache' => [
            'backend' => 'Magento\\Framework\\Cache\\Backend\\Redis',
            'backend_options' => [
                'server'   => '127.0.0.1',
                'port'     => '6379',
                'database' => '1',  // separate database for full page cache
            ],
        ],
    ],
],
'session' => [
    'save'         => 'redis',
    'redis' => [
        'host'     => '127.0.0.1',
        'port'     => '6379',
        'database' => '2',
    ],
],

Use a separate Redis database number for each type. Mixing the page cache and session data in the same database means a cache flush will wipe active sessions, which logs out all your customers. Learned that one the hard way on a live site.

7. Flat Catalog tables speed up large catalogues

By default Magento stores product and category attributes using the EAV (Entity-Attribute-Value) model. For catalogues with thousands of products and many attributes, this means dozens of JOIN operations per product list query. Flat tables consolidate all attributes into a single table per entity type, which is dramatically faster for reads.

# Enable flat catalog in admin: Stores > Configuration > Catalog > Catalog
# Then rebuild the flat tables
php bin/magento indexer:reindex catalog_category_flat
php bin/magento indexer:reindex catalog_product_flat

The tradeoff is that the flat tables need to be kept in sync with the EAV tables, which adds a small overhead to product saves. For read-heavy stores with large catalogues this is almost always worth it.

8. Optimise your indexers and set them to update on schedule

Magento has multiple indexers that rebuild data structures when products, categories, or prices change. Running them on "Update on Save" means every product edit triggers a full or partial reindex, which blocks the save operation and slows down the admin. On stores with large catalogues this can make product editing painfully slow.

# Set all indexers to update on schedule
php bin/magento indexer:set-mode schedule

# Or set a specific indexer
php bin/magento indexer:set-mode schedule catalogrule_rule

# Check current indexer status
php bin/magento indexer:status

With schedule mode, reindexing happens on cron runs rather than during save operations. Editors get fast saves, the index stays reasonably fresh, and you avoid timeout issues when making bulk changes.

9. Enable Varnish for full page cache in production

Magento's built-in full page cache is decent but Varnish is significantly faster for high-traffic stores. Magento generates a Varnish configuration file for you:

php bin/magento varnish:vcl:generate --export-version=6 > /etc/varnish/default.vcl

Set the caching application to Varnish in the admin under Stores, Configuration, Advanced, System, Full Page Cache. One thing that catches developers out: after enabling Varnish you need to set the HTTP port to 80 and let Varnish handle requests on that port, with Magento behind it on a different port. Your web server config needs to reflect this or you will get redirect loops.

10. Use Asynchronous and deferred indexing for imports

If you run regular product imports via CSV or API, synchronous indexing after each import will slow things to a crawl. Enable asynchronous reindexing and let the cron handle it:

# Enable async grid indexing
php bin/magento config:set dev/grid/async_indexing 1

For bulk imports using the Import API, make sure you call php bin/magento indexer:reindex after the import completes rather than relying on the save events to trigger reindexing. Batch imports at the end, not during.

Backend and Admin Tips

11. Customise Admin Grids Without Rewriting the Whole Grid

One of the most common admin customisations is adding a column to an existing grid, like the orders grid or the customers grid. The wrong way is to override the entire grid PHP class. The right way is to use a UI Component XML file to extend just what you need.

Create a layout XML file in your module at view/adminhtml/layout/sales_order_grid.xml:

<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
    <body>
        <referenceBlock name="sales_order_grid">
            <arguments>
                <argument name="data" xsi:type="array">
                    <item name="config" xsi:type="array">
                        <item name="update_url" xsi:type="url" path="mui/index/render"/>
                    </item>
                </argument>
            </arguments>
        </referenceBlock>
    </body>
</page>

Then extend the UI component definition in view/adminhtml/ui_component/sales_order_grid.xml to add your column. This approach survives Magento upgrades far better than class overrides because you are extending, not replacing.

12. Use Virtual types to avoid unnecessary classes

Virtual types are one of Magento's most underused features. They let you create a variation of an existing class with different constructor arguments, without writing a new PHP file. This is useful when you need multiple instances of the same class configured differently.

<!-- di.xml -->
<virtualType name="Vendor\Module\Model\CustomLogger"
             type="Magento\Framework\Logger\Monolog">
    <arguments>
        <argument name="name" xsi:type="string">customModule</argument>
        <argument name="handlers" xsi:type="array">
            <item name="system" xsi:type="object">
                Vendor\Module\Logger\Handler\Custom
            </item>
        </argument>
    </arguments>
</virtualType>

<!-- Use the virtual type as a dependency -->
<type name="Vendor\Module\Model\SomeService">
    <arguments>
        <argument name="logger" xsi:type="object">
            Vendor\Module\Model\CustomLogger
        </argument>
    </arguments>
</type>

This creates a logger instance with custom configuration without writing a new Logger class. Clean, upgrade-safe, and takes five minutes once you understand the pattern.

13. Use Plugins (Interceptors) Instead of Rewrites

Magento 1 developers often reach for class rewrites out of habit. In Magento 2, plugins are almost always the better choice. Plugins let you execute code before, after, or around a public method of any class without replacing the entire class.

<!-- di.xml -->
<type name="Magento\Catalog\Model\Product">
    <plugin name="vendor_module_product_plugin"
            type="Vendor\Module\Plugin\ProductPlugin"
            sortOrder="10"
            disabled="false"/>
</type>

<?php

namespace Vendor\Module\Plugin;

use Magento\Catalog\Model\Product;

class ProductPlugin
{
    // Runs after getName() and can modify the return value
    public function afterGetName(Product $subject, string $result): string
    {
        if ($subject->getTypeId() === 'bundle') {
            return $result . ' (Bundle)';
        }

        return $result;
    }

    // Runs before setPrice() and can modify the arguments
    public function beforeSetPrice(Product $subject, float $price): array
    {
        // Ensure price is never negative
        return [max(0, $price)];
    }
}

Multiple plugins can target the same method and the sortOrder attribute controls execution order. This means your customisation coexists with other modules' plugins rather than one rewrite blocking another entirely.

14. Log to custom files, not the default system log

Everything in Magento logs to var/log/system.log by default. On an active store this file grows fast and becomes almost useless for finding specific module issues. Create a custom logger for your module that writes to its own file:

<?php

namespace Vendor\Module\Logger;

use Monolog\Logger;

class Handler extends \Magento\Framework\Logger\Handler\Base
{
    protected $loggerType = Logger::DEBUG;
    protected $fileName   = '/var/log/vendor_module.log';
}

Register this handler in your module's di.xml using a virtual type (see tip 12 above) and inject it wherever you need logging. Your module's debug output goes to its own file and does not get buried in the system log noise.

Frontend and Theming Tips

15. Extend Parent Themes Rather Than Modifying Them Directly

Never modify Luma or Blank theme files directly. Magento updates will overwrite your changes and you will have no way of knowing what was changed. Always create a child theme that declares the parent:

<!-- app/design/frontend/Vendor/mytheme/theme.xml -->
<theme xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:noNamespaceSchemaLocation="urn:magento:framework:Config/etc/theme.xsd">
    <title>Vendor My Theme</title>
    <parent>Magento/luma</parent>
</theme>

To override a template, copy it from the parent theme into the same relative path in your theme and edit the copy. Magento's theme fallback system will use your version. To override a layout, create a layout XML file with the same name in your theme's layout directory and add only the changes you need.

16. Use the less variable override system properly

Magento 2 uses Less for stylesheets and has a variable system that lets you customise colours, fonts, and spacing without touching the source Less files. Override variables in your theme by creating web/css/source/_variables.less:

// Override the primary colour across the entire theme
@color-orange: #e84040;

// Change the default font
@font-family__base: 'Inter', sans-serif;
@font-family__serif: Georgia, serif;

// Button styling
@button__background: @color-orange;
@button__border-radius: 4px;

// Navigation
@navigation__background: #1a1a2e;
@navigation-level0-item__color: #ffffff;

This propagates through Magento's entire Less stack without you touching a single source file. Most visual customisations can be done entirely through variable overrides. Only write custom Less for things the variable system does not cover.

17. Understand static content deployment

The most common frontend issue I see in production deployments is forgetting to deploy static content, or deploying it for the wrong locales.

# Deploy for all themes and locales
php bin/magento setup:static-content:deploy

# Deploy for specific locales only (faster)
php bin/magento setup:static-content:deploy en_US en_GB

# Deploy a specific theme
php bin/magento setup:static-content:deploy -t Vendor/mytheme en_US

# Use parallel deployment for speed on large stores
php bin/magento setup:static-content:deploy --jobs=4 en_US

If your static content looks correct in developer mode but breaks in production, you almost certainly have a deployment issue. Check that all your locales are included in the deploy command and that the deployment ran successfully after the last code change.

18. Use RequireJS config to load JavaScript properly

Adding JavaScript in Magento 2 is not as simple as dropping a script tag in a template. The right way is through RequireJS, which manages dependencies and load order. Define your JavaScript modules in view/frontend/requirejs-config.js:

var config = {
    map: {
        '*': {
            'customSlider': 'Vendor_Module/js/custom-slider',
        }
    },
    shim: {
        'customSlider': {
            deps: ['jquery'],
        }
    },
    paths: {
        'slick': 'Vendor_Module/js/vendor/slick.min',
    }
};

Then use it in a template or another JavaScript file:

require(['customSlider', 'jquery'], function(CustomSlider, $) {
    var slider = new CustomSlider({
        element: $('.product-gallery'),
        autoplay: true,
    });
});

The RequireJS approach means your JavaScript is only loaded when needed, dependencies are guaranteed to be available, and your code does not conflict with other modules' JavaScript.

Common Mistakes to avoid

19. Do Not use ObjectManager directly in your code

You will see ObjectManager used in old tutorials and even in some core Magento code. Do not follow that pattern in your own modules. Using ObjectManager directly bypasses dependency injection, makes code untestable, and creates hidden dependencies.

<?php

// Wrong. Do not do this.
$objectManager = \Magento\Framework\App\ObjectManager::getInstance();
$product = $objectManager->create(\Magento\Catalog\Model\Product::class);

// Right. Inject dependencies through the constructor.
class MyService
{
    public function __construct(
        private \Magento\Catalog\Model\ProductFactory $productFactory
    ) {}

    public function doSomething(): void
    {
        $product = $this->productFactory->create();
    }
}

The only acceptable place to use ObjectManager directly is in factory classes and proxy classes, and even there Magento generates those automatically through its code generation system.

20. Do Not modify core files

Every Magento update will overwrite your changes. Use plugins, preferences, layout overrides, and template overrides instead. If you find yourself editing a file in vendor/magento/, stop and find the proper extension point instead. There is always one.

21. Run Code egneration after adding new classes

Magento generates proxy classes, factory classes, and interceptors automatically. When you add a new class that uses dependency injection, you may need to regenerate this code:

# Generate interceptors and factories
php bin/magento setup:di:compile

# Clear generated code if something seems wrong
rm -rf generated/code/*
php bin/magento setup:di:compile

If you are getting "Class does not exist" errors for factory or proxy classes, this is almost always the fix. In developer mode Magento generates these on the fly, but in production mode they must be compiled ahead of time.

22. Check your module's sequence in module.xml

If your module depends on another module being loaded first, declare that dependency in etc/module.xml. Without it, your di.xml or layout XML might be processed before the module it depends on, causing hard-to-debug errors.

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
    <module name="Vendor_Module" setup_version="1.0.0">
        <sequence>
            <module name="Magento_Catalog"/>
            <module name="Magento_Sales"/>
        </sequence>
    </module>
</config>

One last thing worth mentioning

Magento 2 rewards developers who take the time to understand its architecture rather than fighting against it. The dependency injection system, the plugin architecture, the UI component framework, and the layout XML system all have learning curves but they exist for good reasons. Once you work with them properly instead of around them, your code is more maintainable, survives upgrades better, and plays well with other modules.

The most expensive Magento projects I have seen are the ones where developers skipped the architecture and went straight to hacking. The technical debt accumulates fast and the upgrade path becomes a rewrite. The extra time spent doing things the Magento way upfront is always worth it.

If there is a specific Magento 2 topic you want covered in more depth, drop a comment below.

Laravel and Prism PHP: The Modern Way to Work with AI Models

noreply@blogger.com (PHP CMS Frameworks) — Sat, 04 Apr 2026 17:01:00 +0000

Every Laravel project that needs AI ends up with a different implementation. One project uses the OpenAI PHP client directly. Another one uses a wrapper someone wrote three years ago that is no longer maintained. A third one is tightly coupled to a specific model, so switching from GPT-4o to Claude requires rewriting half the service layer.

Prism PHP solves this properly. It is a Laravel package that gives you a single, consistent API for working with multiple AI providers. OpenAI, Anthropic Claude, Ollama for local models, Mistral, Gemini, and more, all through the same fluent interface. You switch providers by changing one line. Your application code does not care which model is behind it.

This post covers the full picture. All the supported providers and when to use each one, text generation with structured output, tool calling so your AI can actually interact with your application, and embeddings for semantic search. I will tie all three together with a real-world example at the end so you can see how they work as a system rather than isolated features.

What you need:

Laravel 10 or 11
PHP 8.1+
Composer
API keys for whichever providers you plan to use.
Ollama requires a local install but is free to run.

Why Prism instead of the OpenAI Client directly

The openai-php/laravel client is solid and I have used it in several projects on this blog. But it locks you into OpenAI. If you want to try Claude for a specific task, or use a local Ollama model for development to avoid API costs, you are writing separate integration code for each one.

Prism is inspired by the Vercel AI SDK, which solved this same problem in the JavaScript world. The idea is simple: define a unified interface, write drivers for each provider, and let application code stay completely provider-agnostic. The practical benefits are real.

You can use GPT-4o for general generation, Claude for tasks where it performs better (long document analysis, nuanced writing), and a local Ollama model during development so you are not burning API credits on every test run. All through the same application code. That flexibility is genuinely useful once you start building production AI features.

Supported Providers

Prism currently ships with first-party support for these providers. Each has its own strengths and the right choice depends on the task.

Provider	Best For	Key Models	Cost
OpenAI	General generation, embeddings, function calling	GPT-4o, GPT-4o-mini, text-embedding-3-small	Pay per token
Anthropic	Long documents, reasoning, nuanced analysis	Claude 3.7 Sonnet, Claude 3.5 Haiku	Pay per token
Ollama	Local development, privacy-sensitive data, zero API cost	Llama 3, Mistral, Phi-3, any Ollama model	Free (runs locally)
Mistral	Efficient generation, European data residency	Mistral Large, Mistral Small	Pay per token
Google Gemini	Multimodal tasks, audio and video input	Gemini 1.5 Flash, Gemini 1.5 Pro	Pay per token
xAI (Grok)	Real-time data awareness, alternative to GPT-4	Grok-2	Pay per token

My general approach: OpenAI for embeddings and general tasks, Claude for anything involving long content or nuanced judgment, Ollama for local development. That combination covers most application needs while keeping costs reasonable.

Installation and Configuration

composer require prism-php/prism

Publish the config file:

php artisan vendor:publish --tag=prism-config

This generates config/prism.php. Add your provider credentials to .env:

# OpenAI
OPENAI_API_KEY=sk-your-openai-key

# Anthropic
ANTHROPIC_API_KEY=sk-ant-your-anthropic-key

# Mistral
MISTRAL_API_KEY=your-mistral-key

# Google Gemini
GEMINI_API_KEY=your-gemini-key

# xAI
XAI_API_KEY=your-xai-key

# Ollama runs locally, no API key needed
# Default URL is http://localhost:11434

The config/prism.php file maps these to the relevant providers. You can also set default models per provider here, which saves repeating the model name in every call.

Part 1: Text Generation and Structured Output

The core feature and the one you will use most. Prism's text generation API is chainable and reads naturally, which is one of the things that makes it feel like a proper Laravel package rather than a thin wrapper.

Basic Text Generation

Here is the same prompt sent to three different providers, with zero application code changes between them:

<?php

use Prism\Prism\Facades\Prism;
use Prism\Prism\Enums\Provider;

// OpenAI
$response = Prism::text()
    ->using(Provider::OpenAI, 'gpt-4o')
    ->withSystemPrompt('You are a helpful PHP development assistant.')
    ->withPrompt('Explain what a service container is in Laravel.')
    ->asText();

echo $response->text;

// Swap to Claude, same code
$response = Prism::text()
    ->using(Provider::Anthropic, 'claude-3-7-sonnet-latest')
    ->withSystemPrompt('You are a helpful PHP development assistant.')
    ->withPrompt('Explain what a service container is in Laravel.')
    ->asText();

echo $response->text;

// Or run it locally with Ollama during development
$response = Prism::text()
    ->using(Provider::Ollama, 'llama3')
    ->withSystemPrompt('You are a helpful PHP development assistant.')
    ->withPrompt('Explain what a service container is in Laravel.')
    ->asText();

echo $response->text;

That is the core value proposition right there. Same interface, different provider. If OpenAI has an outage or you want to A/B test Claude versus GPT-4o on a specific prompt, you change one line.

Structured Output with Schema Validation

Getting raw text back is fine for simple tasks. For anything that feeds into application logic, you want structured output. Prism handles this through schema definitions that map directly to PHP objects.

<?php

use Prism\Prism\Facades\Prism;
use Prism\Prism\Enums\Provider;
use Prism\Prism\Schema\ObjectSchema;
use Prism\Prism\Schema\StringSchema;
use Prism\Prism\Schema\IntegerSchema;
use Prism\Prism\Schema\ArraySchema;

$schema = new ObjectSchema(
    name: 'article_analysis',
    description: 'Analysis of a PHP tutorial article',
    properties: [
        new StringSchema('summary', 'One sentence summary of the article'),
        new IntegerSchema('difficulty_level', 'Difficulty from 1 (beginner) to 5 (expert)'),
        new StringSchema('primary_topic', 'The main topic of the article'),
        new ArraySchema(
            'key_concepts',
            'Key technical concepts covered',
            new StringSchema('concept', 'A technical concept mentioned in the article')
        ),
        new ArraySchema(
            'prerequisite_knowledge',
            'What the reader should know before reading this',
            new StringSchema('prerequisite', 'A prerequisite concept or skill')
        ),
    ],
    requiredFields: ['summary', 'difficulty_level', 'primary_topic', 'key_concepts']
);

$articleContent = "Your article text goes here...";

$response = Prism::text()
    ->using(Provider::OpenAI, 'gpt-4o')
    ->withSystemPrompt('You analyse PHP and Laravel tutorial articles.')
    ->withPrompt("Analyse this article:\n\n{$articleContent}")
    ->withSchema($schema)
    ->asStructured();

// $response->structured is a fully typed PHP array matching your schema
$analysis = $response->structured;

echo $analysis['summary'];
echo $analysis['difficulty_level'];
echo implode(', ', $analysis['key_concepts']);

No more parsing freeform text. No more stripping markdown fences from JSON responses. Prism handles the structured output negotiation with the model and gives you a validated PHP array. If the model returns something that does not match the schema, Prism throws rather than silently returning garbage data.

Multi-Turn Conversations

<?php

use Prism\Prism\Facades\Prism;
use Prism\Prism\Enums\Provider;
use Prism\Prism\ValueObjects\Messages\UserMessage;
use Prism\Prism\ValueObjects\Messages\AssistantMessage;

$history = [
    new UserMessage('What is the difference between Laravel jobs and events?'),
    new AssistantMessage('Jobs are queued tasks for deferred work. Events are for broadcasting that something happened in your application...'),
    new UserMessage('Can you show me a code example of a job?'),
];

$response = Prism::text()
    ->using(Provider::Anthropic, 'claude-3-7-sonnet-latest')
    ->withSystemPrompt('You are a Laravel expert.')
    ->withMessages($history)
    ->asText();

echo $response->text;

Part 2: Tool Calling

Tool calling is where things get genuinely interesting. Instead of the AI just generating text, you give it tools it can call, functions that interact with your actual application. The model decides when to use a tool based on the user's request, calls it, gets the result, and incorporates it into its response.

Without tool calling, an AI assistant can only work with what it was trained on. With tool calling, it can check live database records, call external APIs, perform calculations, and do anything else you give it a tool for.

Defining a Tool

<?php

use Prism\Prism\Tool;

// A tool that looks up an order from your database
$orderLookupTool = Tool::as('get_order_status')
    ->for('Look up the status and details of a customer order by order number')
    ->withStringParameter('order_number', 'The order number to look up, e.g. ORD-2025-1234')
    ->using(function (string $order_number): string {
        $order = \App\Models\Order::where('order_number', $order_number)
            ->with('items')
            ->first();

        if (!$order) {
            return json_encode(['error' => 'Order not found']);
        }

        return json_encode([
            'order_number' => $order->order_number,
            'status'       => $order->status,
            'placed_at'    => $order->created_at->format('d M Y'),
            'total'        => '$' . number_format($order->total, 2),
            'items'        => $order->items->count(),
            'tracking'     => $order->tracking_number ?? 'Not yet assigned',
        ]);
    });

The model sees the tool name, description, and parameter definitions. When a user asks something like "what is the status of my order ORD-2025-4821", the model recognises it needs the order lookup tool, calls it with the order number extracted from the message, gets the JSON result back, and uses it to form a natural language response.

Using Multiple Tools Together

<?php

use Prism\Prism\Facades\Prism;
use Prism\Prism\Enums\Provider;
use Prism\Prism\Tool;

$orderLookupTool = Tool::as('get_order_status')
    ->for('Look up order status by order number')
    ->withStringParameter('order_number', 'The order number')
    ->using(function (string $order_number): string {
        // Your order lookup logic here
        return json_encode(['status' => 'shipped', 'tracking' => 'TRK123456']);
    });

$productSearchTool = Tool::as('search_products')
    ->for('Search the product catalogue by keyword')
    ->withStringParameter('keyword', 'Search term to find products')
    ->withIntegerParameter('limit', 'Maximum number of results to return')
    ->using(function (string $keyword, int $limit = 5): string {
        $products = \App\Models\Product::search($keyword)
            ->take($limit)
            ->get(['name', 'price', 'in_stock']);

        return json_encode($products->toArray());
    });

$refundPolicyTool = Tool::as('get_refund_policy')
    ->for('Retrieve the current refund and returns policy')
    ->using(function (): string {
        return "Orders can be returned within 30 days of delivery. " .
               "Refunds process within 3 to 5 business days. " .
               "Items must be unused and in original packaging.";
    });

$response = Prism::text()
    ->using(Provider::OpenAI, 'gpt-4o')
    ->withSystemPrompt(
        'You are a helpful customer support assistant for an online store. ' .
        'Use the available tools to look up order details, products, and policies. ' .
        'Always check actual data before making claims about orders or policies.'
    )
    ->withPrompt("I ordered something last week, order number ORD-2025-4821. " .
                 "Has it shipped yet? Also, what's your return policy?")
    ->withTools([$orderLookupTool, $productSearchTool, $refundPolicyTool])
    ->withMaxSteps(5)
    ->asText();

echo $response->text;

The withMaxSteps(5) call is important. It limits how many tool calls the model can make in a single request, preventing runaway chains where the model keeps calling tools indefinitely. Five steps is plenty for most support interactions.

What happens behind the scenes: the model reads the user message, decides it needs to call get_order_status with order number ORD-2025-4821, Prism runs your PHP function, returns the result to the model, the model sees the shipping status, then calls get_refund_policy for the second question, gets that result, and writes a complete response covering both questions using real data from your application.

Part 3: Embeddings for Semantic Search

Embeddings convert text into a vector, a list of floating point numbers that represent the semantic meaning of the text. Two pieces of text that mean similar things will have vectors that are close together in that high-dimensional space, even if the actual words used are completely different.

Prism handles embeddings through the same clean interface as text generation.

<?php

use Prism\Prism\Facades\Prism;
use Prism\Prism\Enums\Provider;

// Generate an embedding for a piece of text
$response = Prism::embeddings()
    ->using(Provider::OpenAI, 'text-embedding-3-small')
    ->fromInput('How do I reset my account password?')
    ->create();

$vector = $response->embeddings[0]->embedding;
// $vector is an array of 1536 floats representing the semantic meaning

You can also embed multiple texts in a single API call, which is more efficient when indexing content:

<?php

$response = Prism::embeddings()
    ->using(Provider::OpenAI, 'text-embedding-3-small')
    ->fromInput([
        'How do I reset my password?',
        'Account recovery steps for locked accounts',
        'Changing your email address in account settings',
        'Two-factor authentication setup guide',
    ])
    ->create();

foreach ($response->embeddings as $index => $embedding) {
    echo "Text {$index}: " . count($embedding->embedding) . " dimensions\n";
}

Real-World Example: Tying All Three Together

Here is where it gets practical. I will build a customer support assistant that uses all three Prism features together: embeddings to find relevant knowledge base articles, tool calling to look up live order data, and structured text generation to produce consistent responses.

The scenario is a support bot for a Laravel e-commerce application. The bot needs to answer questions about orders using real database data, find relevant help articles using semantic search, and produce responses that follow a consistent format.

Database Setup for Knowledge Base

php artisan make:migration create_knowledge_base_table

<?php

Schema::create('knowledge_base_articles', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->json('embedding')->nullable();
    $table->string('category');
    $table->timestamps();
});

The Knowledge Base Indexer

<?php

namespace App\Services;

use App\Models\KnowledgeBaseArticle;
use Prism\Prism\Facades\Prism;
use Prism\Prism\Enums\Provider;

class KnowledgeBaseIndexer
{
    public function indexAll(): void
    {
        $articles = KnowledgeBaseArticle::whereNull('embedding')->get();

        foreach ($articles->chunk(20) as $batch) {
            $texts = $batch->map(fn($a) => $a->title . "\n\n" . $a->content)
                           ->toArray();

            $response = Prism::embeddings()
                ->using(Provider::OpenAI, 'text-embedding-3-small')
                ->fromInput($texts)
                ->create();

            foreach ($batch as $index => $article) {
                $article->update([
                    'embedding' => $response->embeddings[$index]->embedding,
                ]);
            }

            usleep(200000);
        }
    }

    public function findRelevant(string $query, int $topK = 3): array
    {
        $queryResponse = Prism::embeddings()
            ->using(Provider::OpenAI, 'text-embedding-3-small')
            ->fromInput($query)
            ->create();

        $queryVector = $queryResponse->embeddings[0]->embedding;

        // Load articles and compute cosine similarity in PHP
        // For production with large knowledge bases, use pgvector instead
        $articles = KnowledgeBaseArticle::whereNotNull('embedding')->get();

        $scored = $articles->map(function ($article) use ($queryVector) {
            $articleVector = $article->embedding;
            return [
                'article'    => $article,
                'similarity' => $this->cosineSimilarity($queryVector, $articleVector),
            ];
        })
        ->filter(fn($item) => $item['similarity'] > 0.75)
        ->sortByDesc('similarity')
        ->take($topK);

        return $scored->pluck('article')->toArray();
    }

    private function cosineSimilarity(array $a, array $b): float
    {
        $dot  = array_sum(array_map(fn($x, $y) => $x * $y, $a, $b));
        $magA = sqrt(array_sum(array_map(fn($x) => $x ** 2, $a)));
        $magB = sqrt(array_sum(array_map(fn($x) => $x ** 2, $b)));

        return ($magA * $magB) > 0 ? $dot / ($magA * $magB) : 0.0;
    }
}

The Support Assistant Service

<?php

namespace App\Services;

use Prism\Prism\Facades\Prism;
use Prism\Prism\Enums\Provider;
use Prism\Prism\Tool;
use Prism\Prism\Schema\ObjectSchema;
use Prism\Prism\Schema\StringSchema;
use Prism\Prism\Schema\ArraySchema;

class CustomerSupportAssistant
{
    public function __construct(
        private KnowledgeBaseIndexer $knowledgeBase
    ) {}

    public function respond(string $customerMessage, string $customerId): array
    {
        // Step 1: Find relevant knowledge base articles using embeddings
        $relevantArticles = $this->knowledgeBase->findRelevant($customerMessage);

        $knowledgeContext = collect($relevantArticles)
            ->map(fn($a) => "### {$a->title}\n{$a->content}")
            ->join("\n\n---\n\n");

        // Step 2: Define tools for live data access
        $orderTool = Tool::as('get_order')
            ->for('Look up order details and status for a specific order number')
            ->withStringParameter('order_number', 'The order number, e.g. ORD-2025-1234')
            ->using(function (string $order_number) use ($customerId): string {
                $order = \App\Models\Order::where('order_number', $order_number)
                    ->where('customer_id', $customerId)
                    ->with('items', 'shipment')
                    ->first();

                if (!$order) {
                    return json_encode([
                        'error' => 'Order not found or does not belong to this customer',
                    ]);
                }

                return json_encode([
                    'order_number' => $order->order_number,
                    'status'       => $order->status,
                    'placed_at'    => $order->created_at->format('d M Y'),
                    'total'        => '$' . number_format($order->total, 2),
                    'item_count'   => $order->items->count(),
                    'tracking'     => $order->shipment->tracking_number ?? 'Not yet assigned',
                    'carrier'      => $order->shipment->carrier ?? null,
                    'estimated_delivery' => $order->shipment->estimated_delivery ?? null,
                ]);
            });

        $accountTool = Tool::as('get_account_info')
            ->for('Retrieve customer account information like email and membership status')
            ->using(function () use ($customerId): string {
                $customer = \App\Models\Customer::find($customerId);

                if (!$customer) {
                    return json_encode(['error' => 'Customer not found']);
                }

                return json_encode([
                    'name'              => $customer->name,
                    'email'             => $customer->email,
                    'member_since'      => $customer->created_at->format('M Y'),
                    'membership_tier'   => $customer->tier,
                    'total_orders'      => $customer->orders()->count(),
                ]);
            });

        // Step 3: Define schema for structured response
        $responseSchema = new ObjectSchema(
            name: 'support_response',
            description: 'A structured customer support response',
            properties: [
                new StringSchema('message', 'The response message to send to the customer'),
                new StringSchema(
                    'escalation_level',
                    'Whether to escalate: "none", "agent", or "manager"'
                ),
                new StringSchema('sentiment', 'Customer sentiment detected: "positive", "neutral", "frustrated"'),
                new ArraySchema(
                    'follow_up_actions',
                    'Actions the support team should take after this interaction',
                    new StringSchema('action', 'A follow-up action item')
                ),
            ],
            requiredFields: ['message', 'escalation_level', 'sentiment']
        );

        // Step 4: Generate the response using text generation, tools, and schema
        $systemPrompt = "You are a helpful and empathetic customer support assistant.

Relevant knowledge base articles for this conversation:
{$knowledgeContext}

Guidelines:
- Use the knowledge base content above when it is relevant to the customer's question.
- Use the available tools to look up live order and account data when needed.
- Keep responses concise and clear, two to three sentences where possible.
- If the customer is frustrated, acknowledge their feelings first before solving the problem.
- Escalate to 'agent' if the issue requires human judgment or account changes.
- Escalate to 'manager' only if the customer is threatening to leave or requests a manager specifically.
- Never guess at order details, always use the get_order tool for specific order questions.";

        $response = Prism::text()
            ->using(Provider::Anthropic, 'claude-3-7-sonnet-latest')
            ->withSystemPrompt($systemPrompt)
            ->withPrompt($customerMessage)
            ->withTools([$orderTool, $accountTool])
            ->withMaxSteps(4)
            ->withSchema($responseSchema)
            ->asStructured();

        return $response->structured;
    }
}

The Controller

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Services\CustomerSupportAssistant;

class SupportController extends Controller
{
    public function __construct(
        private CustomerSupportAssistant $assistant
    ) {}

    public function chat(Request $request)
    {
        $request->validate([
            'message' => 'required|string|max:1000',
        ]);

        $customerId = auth()->id();
        $message    = $request->input('message');

        try {
            $response = $this->assistant->respond($message, $customerId);

            return response()->json([
                'reply'            => $response['message'],
                'escalation_level' => $response['escalation_level'],
                'sentiment'        => $response['sentiment'],
                'follow_up'        => $response['follow_up_actions'] ?? [],
            ]);

        } catch (\Exception $e) {
            report($e);
            return response()->json([
                'reply' => 'Something went wrong. Please try again in a moment.',
            ], 500);
        }
    }
}

What This System Produces

Here is a realistic example of what the full pipeline returns for a frustrated customer asking about a delayed order:

Customer message: "My order ORD-2025-4821 was supposed to arrive three days ago
and I still haven't received it. This is really frustrating."

System flow:
1. Embeddings search finds "Shipping delays FAQ" and "How to track your order" articles
2. Claude reads the relevant knowledge base content
3. Claude calls get_order tool with order number ORD-2025-4821
4. Tool returns: { status: "shipped", tracking: "TRK987654", carrier: "FedEx",
                   estimated_delivery: "2 days ago" }
5. Claude generates structured response

Response:
{
  "message": "I completely understand your frustration, and I am sorry your order
              is running late. I can see ORD-2025-4821 shipped with FedEx and the
              tracking number is TRK987654. FedEx is showing a delay on their end,
              but the package is still in transit. You can track it directly at
              fedex.com using that number for the most current status.",
  "escalation_level": "none",
  "sentiment": "frustrated",
  "follow_up_actions": [
    "Monitor order TRK987654 for delivery confirmation",
    "If not delivered within 48 hours, initiate trace request with FedEx",
    "Flag customer account for priority handling on next contact"
  ]
}

The sentiment flag lets your frontend show a different UI for frustrated customers. The escalation level drives routing logic. The follow-up actions can be stored and assigned to your support team automatically. This is not just a chatbot, it is a complete support workflow powered by three Prism features working together.

Testing Prism Code

One of the things that makes Prism genuinely production-ready is its testing utilities. You do not want real API calls firing during unit tests. Prism ships with response faking so you can test your application logic without hitting any external APIs.

<?php

use Prism\Prism\Facades\Prism;
use Prism\Prism\Testing\PrismFake;
use Prism\Prism\ValueObjects\TextResult;

it('generates a support response for order queries', function () {
    $fakeResponse = new TextResult(
        text: '{"message": "Your order has shipped.", "escalation_level": "none", "sentiment": "neutral"}',
        finishReason: 'stop',
        usage: ['prompt_tokens' => 100, 'completion_tokens' => 50]
    );

    Prism::fake([$fakeResponse]);

    $assistant = app(CustomerSupportAssistant::class);
    $result    = $assistant->respond('Where is my order?', customerId: 1);

    expect($result['escalation_level'])->toBe('none');
    expect($result['sentiment'])->toBe('neutral');

    Prism::assertCallCount(1);
    Prism::assertLastCallUsedProvider('anthropic');
});

Prism::fake() intercepts all Prism calls and returns your predefined responses. Prism::assertCallCount() and Prism::assertLastCallUsedProvider() let you verify your code is making the right calls. Clean, straightforward, and no real API usage during tests.

Switching Providers Without Touching Application Code

One last thing worth showing explicitly, because it is the whole point of Prism. You can make your provider configurable through your .env file so you can switch without a code change:

# .env
AI_PROVIDER=anthropic
AI_MODEL=claude-3-7-sonnet-latest

<?php

// In your service or controller
$response = Prism::text()
    ->using(
        config('ai.provider', 'openai'),
        config('ai.model', 'gpt-4o')
    )
    ->withPrompt($prompt)
    ->asText();

Change the provider in .env, restart the queue workers, done. No code changes, no redeployment of application logic. That is the practical benefit of a unified interface. You build once against Prism's API and gain the flexibility to move between providers as your needs evolve, pricing changes, or a new model comes along that performs better on your specific tasks.

Prism is still relatively young but it is actively maintained and the API has stabilised enough to build production features on. For any new Laravel project that involves AI, it is the first package I reach for now. The alternative, direct API clients for each provider, creates the kind of fragmented codebase that becomes a maintenance problem fast.

Build a RAG Pipeline Inside Joomla for Intelligent Site Search

noreply@blogger.com (PHP CMS Frameworks) — Tue, 31 Mar 2026 18:01:00 +0000

Joomla's built-in search has always had the same fundamental limitation. It is keyword-based. A visitor types "how do I reset my account" and the search engine looks for articles containing those exact words. If your article uses the phrase "recover your login credentials" instead, it does not show up. The visitor gets no results, concludes your site does not have the answer, and leaves.

This is not a Joomla problem specifically. It is what keyword search does. It matches strings, not meaning. RAG, Retrieval-Augmented Generation, solves this at the architecture level. Instead of matching keywords, it converts both your content and the search query into vector embeddings, finds content that is semantically similar, and uses an LLM to generate a direct answer from that content. A visitor asking "how do I reset my account" gets a proper answer even if none of your articles use those exact words.

I will walk through the full implementation. We will cover the three main vector storage options honestly so you can make the right choice for your setup, then go deep on building the complete RAG pipeline inside a custom Joomla component using PostgreSQL with pgvector and OpenAI.

What you need: Joomla 4 or 5, PHP 8.1+, Composer, PostgreSQL with the pgvector extension installed, and an OpenAI API key.

What RAG Actually Does, Step by Step

Before writing any code it is worth being clear about what the pipeline actually does at each stage. RAG is one of those terms that gets thrown around loosely and the implementation details matter.

Phase 1: Indexing (runs once, then on content updates)
        ↓
Fetch all published Joomla articles
        ↓
Split long articles into chunks
        ↓
Send each chunk to OpenAI Embeddings API
        ↓
Store the chunk text and its embedding vector in PostgreSQL

Phase 2: Search (runs on every user query)
        ↓
User submits a search query
        ↓
Convert query to an embedding vector via OpenAI
        ↓
Find the most semantically similar chunks using pgvector
        ↓
Send retrieved chunks plus the original query to GPT-4o
        ↓
GPT-4o generates a direct answer grounded in your content
        ↓
Return the answer and source article links to the user

The indexing phase is the slower one and only needs to run when content changes. The search phase is what your visitors experience and it needs to be fast. Keeping those two concerns separate in the architecture makes both easier to manage.

Three Vector Storage Options for Joomla

This is the decision that shapes the rest of the implementation. There is no universally correct answer here, the right choice depends on your infrastructure, team, and content volume.

Option 1: PostgreSQL with pgvector

pgvector is an open source PostgreSQL extension that adds a native vector data type and similarity search operators. You store embeddings directly in a PostgreSQL table alongside your chunk text and metadata. Similarity search runs as a standard SQL query using the cosine distance operator.

The big advantage is that you are not adding a new infrastructure dependency. If you are already running PostgreSQL, this is just an extension install and a new table. Queries are fast, the data lives in your existing database stack, and you have full control. The limitation is that at very large scale, hundreds of thousands of chunks, you need to tune the index carefully to maintain query speed.

This is what we are building in this post. It is the right default for most Joomla sites.

Option 2: MySQL with a Vector Similarity Workaround

Joomla ships with MySQL as its default database, so this is the path of least resistance from an infrastructure standpoint. MySQL 9.0 added experimental vector support but it is not production-ready for most use cases yet. The practical workaround is to store embeddings as JSON or a serialised float array, fetch candidate chunks using a broad text filter, then do the cosine similarity calculation in PHP.

This works for small content sets, a few hundred articles. It gets slow quickly as the content volume grows because you are doing similarity math in PHP rather than in an optimised database index. If your Joomla site runs MySQL and you cannot add PostgreSQL, this is a viable starting point but plan for a migration if the search volume grows.

Option 3: External Vector Store, Pinecone or Qdrant

Pinecone and Qdrant are purpose-built vector databases. You send embeddings to their API, they handle storage and indexing, and you query them via HTTP. Both have generous free tiers for getting started.

The advantage is performance at scale and zero infrastructure management on your end. The disadvantages are an additional external dependency, data leaving your infrastructure, API rate limits, and ongoing costs that grow with your content volume. For enterprise Joomla sites with strict data residency requirements, an external service is often a non-starter.

Good fit for teams that want to move fast without managing PostgreSQL, or sites with very high search volume where a dedicated vector store makes sense operationally.

We are going with pgvector. Here is the full build.

Install pgvector and Set Up the Database Table

First, install the pgvector extension in your PostgreSQL database. If you have superuser access:

CREATE EXTENSION IF NOT EXISTS vector;

If you are on a managed PostgreSQL service like AWS RDS or Supabase, pgvector is available as an enabled extension in the console without needing superuser access.

Create the table that will store your article chunks and their embeddings. Run this in your PostgreSQL database, this is a separate database from Joomla's MySQL database:

CREATE TABLE joomla_article_embeddings (
    id           SERIAL PRIMARY KEY,
    article_id   INTEGER NOT NULL,
    article_title TEXT NOT NULL,
    chunk_index  INTEGER NOT NULL,
    chunk_text   TEXT NOT NULL,
    embedding    vector(1536),
    url          TEXT,
    created_at   TIMESTAMP DEFAULT NOW(),
    updated_at   TIMESTAMP DEFAULT NOW()
);

CREATE INDEX ON joomla_article_embeddings
    USING ivfflat (embedding vector_cosine_ops)
    WITH (lists = 100);

CREATE INDEX ON joomla_article_embeddings (article_id);

The embedding dimension is 1536 because that is what OpenAI's text-embedding-3-small model outputs. If you use text-embedding-3-large instead, change this to 3072. The ivfflat index is what makes similarity search fast at scale. The lists value of 100 is a reasonable starting point, tune it upward if you have more than 100,000 chunks.

Custom Joomla Component Structure

We will build this as a custom Joomla component. Create the following structure under components/com_ragsearch:

components/com_ragsearch/
    ragsearch.xml
    src/
        Service/
            OpenAIService.php
            VectorStoreService.php
            ArticleChunkerService.php
            RAGSearchService.php
        Controller/
            SearchController.php
        View/
            Search/
                HtmlView.php
                tmpl/
                    default.php
    tmpl/
        index.php

administrator/components/com_ragsearch/
    src/
        Controller/
            IndexController.php

Install the OpenAI PHP client and a PostgreSQL driver via Composer in your Joomla root:

composer require openai-php/client
composer require doctrine/dbal

The OpenAI Service

Create src/Service/OpenAIService.php:

<?php

namespace Joomla\Component\Ragsearch\Site\Service;

use OpenAI;

class OpenAIService
{
    private $client;

    public function __construct()
    {
        $params      = \JComponentHelper::getParams('com_ragsearch');
        $apiKey      = $params->get('openai_api_key');
        $this->client = OpenAI::client($apiKey);
    }

    public function embed(string $text): array
    {
        $response = $this->client->embeddings()->create([
            'model' => 'text-embedding-3-small',
            'input' => $text,
        ]);

        return $response->embeddings[0]->embedding;
    }

    public function embedBatch(array $texts): array
    {
        $response = $this->client->embeddings()->create([
            'model' => 'text-embedding-3-small',
            'input' => $texts,
        ]);

        $embeddings = [];
        foreach ($response->embeddings as $item) {
            $embeddings[$item->index] = $item->embedding;
        }

        return $embeddings;
    }

    public function generateAnswer(string $query, array $chunks): string
    {
        $context = implode("\n\n---\n\n", array_column($chunks, 'chunk_text'));

        $response = $this->client->chat()->create([
            'model'       => 'gpt-4o',
            'temperature' => 0.3,
            'max_tokens'  => 600,
            'messages'    => [
                [
                    'role'    => 'system',
                    'content' => 'You are a helpful site assistant. Answer the user question
                                  using only the content provided below. If the content does
                                  not contain enough information to answer, say so honestly.
                                  Do not make up information. Keep answers clear and concise.',
                ],
                [
                    'role'    => 'user',
                    'content' => "Content from our site:\n\n{$context}\n\nQuestion: {$query}",
                ],
            ],
        ]);

        return $response->choices[0]->message->content;
    }
}

Notice the embedBatch method. When indexing articles, sending texts in batches rather than one at a time cuts the number of API calls significantly and speeds up the indexing process. Use it during the indexing phase, use embed for single query embeddings at search time.

The Article Chunker Service

Long articles need to be split into chunks before embedding. Embedding an entire 3,000-word article as a single vector produces a representation that is too diffuse to be useful for retrieval. Smaller focused chunks give the similarity search something meaningful to match against.

Create src/Service/ArticleChunkerService.php:

<?php

namespace Joomla\Component\Ragsearch\Site\Service;

class ArticleChunkerService
{
    private int $chunkSize    = 400;
    private int $chunkOverlap = 50;

    public function chunk(string $text): array
    {
        // Strip HTML tags from article body
        $clean = strip_tags($text);

        // Normalise whitespace
        $clean = preg_replace('/\s+/', ' ', $clean);
        $clean = trim($clean);

        $words  = explode(' ', $clean);
        $total  = count($words);
        $chunks = [];
        $start  = 0;

        while ($start < $total) {
            $end        = min($start + $this->chunkSize, $total);
            $chunkWords = array_slice($words, $start, $end - $start);
            $chunks[]   = implode(' ', $chunkWords);

            // Move forward by chunkSize minus overlap
            // so consecutive chunks share some context
            $start += ($this->chunkSize - $this->chunkOverlap);

            if ($start >= $total) {
                break;
            }
        }

        return array_filter($chunks, fn($c) => strlen(trim($c)) > 50);
    }
}

The overlap between chunks matters more than it might seem. If a key sentence sits right at the boundary between two chunks, without overlap it gets split in half and neither chunk represents that idea well. A 50-word overlap means boundary content appears in both adjacent chunks, so the similarity search is more likely to retrieve it when it is relevant.

The Vector Store Service

Create src/Service/VectorStoreService.php:

<?php

namespace Joomla\Component\Ragsearch\Site\Service;

use Doctrine\DBAL\DriverManager;

class VectorStoreService
{
    private $conn;

    public function __construct()
    {
        $params      = \JComponentHelper::getParams('com_ragsearch');

        $this->conn = DriverManager::getConnection([
            'dbname'   => $params->get('pg_database'),
            'user'     => $params->get('pg_user'),
            'password' => $params->get('pg_password'),
            'host'     => $params->get('pg_host', 'localhost'),
            'port'     => $params->get('pg_port', 5432),
            'driver'   => 'pdo_pgsql',
        ]);
    }

    public function upsertChunk(
        int    $articleId,
        string $title,
        int    $chunkIndex,
        string $chunkText,
        array  $embedding,
        string $url
    ): void {
        // Delete existing chunks for this article and index first
        $this->conn->executeStatement(
            'DELETE FROM joomla_article_embeddings
             WHERE article_id = :id AND chunk_index = :idx',
            ['id' => $articleId, 'idx' => $chunkIndex]
        );

        $vectorLiteral = '[' . implode(',', $embedding) . ']';

        $this->conn->executeStatement(
            'INSERT INTO joomla_article_embeddings
                (article_id, article_title, chunk_index, chunk_text, embedding, url)
             VALUES
                (:article_id, :title, :chunk_index, :chunk_text, :embedding, :url)',
            [
                'article_id'  => $articleId,
                'title'       => $title,
                'chunk_index' => $chunkIndex,
                'chunk_text'  => $chunkText,
                'embedding'   => $vectorLiteral,
                'url'         => $url,
            ]
        );
    }

    public function similaritySearch(array $queryEmbedding, int $topK = 5): array
    {
        $vectorLiteral = '[' . implode(',', $queryEmbedding) . ']';

        $sql = "SELECT
                    article_id,
                    article_title,
                    chunk_text,
                    url,
                    1 - (embedding <=> :embedding::vector) AS similarity
                FROM joomla_article_embeddings
                ORDER BY embedding <=> :embedding::vector
                LIMIT :limit";

        $stmt = $this->conn->executeQuery(
            $sql,
            [
                'embedding' => $vectorLiteral,
                'limit'     => $topK,
            ]
        );

        return $stmt->fetchAllAssociative();
    }

    public function deleteArticle(int $articleId): void
    {
        $this->conn->executeStatement(
            'DELETE FROM joomla_article_embeddings WHERE article_id = :id',
            ['id' => $articleId]
        );
    }
}

The <=> operator is pgvector's cosine distance operator. Cosine distance measures the angle between two vectors rather than the straight-line distance between them, which works better for text embeddings because it focuses on direction, meaning, rather than magnitude. The similarity score in the SELECT is calculated as 1 - cosine_distance, so a score of 1.0 is a perfect match and 0.0 is completely unrelated.

The Indexing Controller

This runs from the Joomla administrator backend. It fetches all published articles, chunks them, embeds them in batches, and stores everything in PostgreSQL. You run this once to build the initial index and then on a schedule or via a hook when articles are updated.

Create administrator/components/com_ragsearch/src/Controller/IndexController.php:

<?php

namespace Joomla\Component\Ragsearch\Administrator\Controller;

use Joomla\CMS\MVC\Controller\BaseController;
use Joomla\Component\Ragsearch\Site\Service\OpenAIService;
use Joomla\Component\Ragsearch\Site\Service\VectorStoreService;
use Joomla\Component\Ragsearch\Site\Service\ArticleChunkerService;

class IndexController extends BaseController
{
    private int $batchSize = 20;

    public function build(): void
    {
        $db      = $this->app->getDatabase();
        $chunker = new ArticleChunkerService();
        $openai  = new OpenAIService();
        $store   = new VectorStoreService();

        // Fetch all published Joomla articles
        $query = $db->getQuery(true)
            ->select(['a.id', 'a.title', 'a.introtext', 'a.fulltext'])
            ->from($db->quoteName('#__content', 'a'))
            ->where($db->quoteName('a.state') . ' = 1');

        $articles = $db->setQuery($query)->loadObjectList();

        $indexed = 0;
        $errors  = 0;

        foreach ($articles as $article) {
            try {
                $fullContent = $article->title . "\n\n"
                             . strip_tags($article->introtext) . "\n\n"
                             . strip_tags($article->fulltext);

                $chunks = $chunker->chunk($fullContent);

                if (empty($chunks)) {
                    continue;
                }

                $url = \JRoute::_(
                    'index.php?option=com_content&view=article&id=' . $article->id
                );

                // Delete old embeddings for this article before re-indexing
                $store->deleteArticle($article->id);

                // Process chunks in batches to reduce API calls
                $chunkBatches = array_chunk($chunks, $this->batchSize);

                foreach ($chunkBatches as $batchIndex => $batch) {
                    $embeddings = $openai->embedBatch($batch);

                    foreach ($batch as $i => $chunkText) {
                        $globalIndex = ($batchIndex * $this->batchSize) + $i;
                        $embedding   = $embeddings[$i] ?? null;

                        if (!$embedding) {
                            continue;
                        }

                        $store->upsertChunk(
                            $article->id,
                            $article->title,
                            $globalIndex,
                            $chunkText,
                            $embedding,
                            $url
                        );
                    }

                    // Small pause between batches to stay within API rate limits
                    usleep(200000);
                }

                $indexed++;

            } catch (\Exception $e) {
                $errors++;
                \JLog::add(
                    'RAG indexing failed for article ' . $article->id . ': ' . $e->getMessage(),
                    \JLog::ERROR,
                    'com_ragsearch'
                );
            }
        }

        $this->app->enqueueMessage(
            "Indexing complete. Articles indexed: {$indexed}. Errors: {$errors}.",
            $errors > 0 ? 'warning' : 'success'
        );

        $this->setRedirect('index.php?option=com_ragsearch');
    }
}

The RAG Search Service

Create src/Service/RAGSearchService.php:

<?php

namespace Joomla\Component\Ragsearch\Site\Service;

class RAGSearchService
{
    public function __construct(
        private OpenAIService     $openai,
        private VectorStoreService $store
    ) {}

    public function search(string $query): array
    {
        if (strlen(trim($query)) < 3) {
            return [
                'answer'  => 'Please enter a more specific question.',
                'sources' => [],
            ];
        }

        // Convert the query to a vector embedding
        $queryEmbedding = $this->openai->embed($query);

        // Find the most semantically similar chunks
        $chunks = $this->store->similaritySearch($queryEmbedding, topK: 5);

        if (empty($chunks)) {
            return [
                'answer'  => 'No relevant content found for your query. Try rephrasing your question.',
                'sources' => [],
            ];
        }

        // Filter out low-similarity results
        $relevantChunks = array_filter(
            $chunks,
            fn($c) => ($c['similarity'] ?? 0) > 0.75
        );

        if (empty($relevantChunks)) {
            return [
                'answer'  => 'I could not find content closely matching your question. Please try different keywords.',
                'sources' => [],
            ];
        }

        // Generate a direct answer grounded in the retrieved chunks
        $answer = $this->openai->generateAnswer($query, $relevantChunks);

        // Deduplicate sources by article ID
        $sources = [];
        foreach ($relevantChunks as $chunk) {
            $aid = $chunk['article_id'];
            if (!isset($sources[$aid])) {
                $sources[$aid] = [
                    'title' => $chunk['article_title'],
                    'url'   => $chunk['url'],
                ];
            }
        }

        return [
            'answer'  => $answer,
            'sources' => array_values($sources),
        ];
    }
}

The similarity threshold of 0.75 is worth paying attention to. Below that score the retrieved chunks are probably not relevant enough to be useful for generating an answer. You can adjust this up or down depending on how your content is structured and how specific the queries on your site tend to be. Start at 0.75 and tune based on real search results.

The Search Controller and View

Create src/Controller/SearchController.php:

<?php

namespace Joomla\Component\Ragsearch\Site\Controller;

use Joomla\CMS\MVC\Controller\BaseController;
use Joomla\Component\Ragsearch\Site\Service\OpenAIService;
use Joomla\Component\Ragsearch\Site\Service\VectorStoreService;
use Joomla\Component\Ragsearch\Site\Service\RAGSearchService;

class SearchController extends BaseController
{
    public function search(): void
    {
        $query = trim($this->input->getString('q', ''));

        $result = ['answer' => '', 'sources' => [], 'query' => $query];

        if (!empty($query)) {
            try {
                $service = new RAGSearchService(
                    new OpenAIService(),
                    new VectorStoreService()
                );

                $result = array_merge($result, $service->search($query));

            } catch (\Exception $e) {
                $result['answer'] = 'Search is temporarily unavailable. Please try again shortly.';
                \JLog::add('RAG search error: ' . $e->getMessage(), \JLog::ERROR, 'com_ragsearch');
            }
        }

        $this->app->setUserState('com_ragsearch.result', $result);
        $this->setRedirect(\JRoute::_('index.php?option=com_ragsearch&view=search'));
    }
}

The Blade-equivalent Joomla view template at src/View/Search/tmpl/default.php:

<?php defined('_JEXEC') or die; ?>

<div class="rag-search">

    <form method="POST" action="<?php echo JRoute::_('index.php?option=com_ragsearch&task=search.search'); ?>">
        <?php echo JHtml::_('form.token'); ?>
        <input type="text"
               name="q"
               value="<?php echo htmlspecialchars($this->result['query'] ?? ''); ?>"
               placeholder="Ask anything about our site..."
               autocomplete="off">
        <button type="submit">Search</button>
    </form>

    <?php if (!empty($this->result['answer'])) : ?>

        <div class="rag-answer">
            <h3>Answer</h3>
            <p><?php echo nl2br(htmlspecialchars($this->result['answer'])); ?></p>
        </div>

        <?php if (!empty($this->result['sources'])) : ?>
            <div class="rag-sources">
                <h4>Sources</h4>
                <ul>
                    <?php foreach ($this->result['sources'] as $source) : ?>
                        <li>
                            <a href="<?php echo htmlspecialchars($source['url']); ?>">
                                <?php echo htmlspecialchars($source['title']); ?>
                            </a>
                        </li>
                    <?php endforeach; ?>
                </ul>
            </div>
        <?php endif; ?>

    <?php endif; ?>

</div>

Keeping the Index fresh

The index goes stale the moment an article is updated and not re-indexed. There are two clean ways to handle this in Joomla.

The first is a Joomla plugin that hooks into onContentAfterSave and triggers re-indexing for the saved article specifically. This keeps the index fresh in real time but adds latency to every article save operation.

<?php

class PlgContentRagsearchIndex extends JPlugin
{
    public function onContentAfterSave(
        string $context,
        object $article,
        bool   $isNew
    ): void {
        if ($context !== 'com_content.article') {
            return;
        }

        if ((int) $article->state !== 1) {
            return;
        }

        // Dispatch a Joomla queue task instead of indexing synchronously
        // to avoid blocking the article save response
        \Joomla\CMS\Queue\QueueFacade::push('ragsearch.index_article', [
            'article_id' => $article->id,
        ]);
    }
}

The second approach is a scheduled CLI task that re-indexes all articles on a schedule, say every hour or every night. For sites where content does not change frequently, a nightly re-index via Joomla's task scheduler is simpler and puts zero overhead on the save operation.

For most sites the scheduled approach is the right default. Use the plugin approach only if your content changes continuously throughout the day and freshness matters within minutes.

What this looks like for a Real Visitor

Here is a concrete example. Say your Joomla site has articles about software products and a visitor types: "what happens if I cancel my subscription mid-month?"

Your articles probably use phrases like "pro-rata refund policy", "billing cycle", "account downgrade", not the exact words the visitor used. Keyword search returns nothing. The RAG pipeline converts the query to a vector, finds three chunks from your billing and account articles that are semantically close to that question, feeds them to GPT-4o, and returns something like:

"If you cancel mid-month, your account remains active until the end of your current billing period. You will not be charged for the following month. Refunds for unused days are not issued automatically but can be requested within 7 days of cancellation by contacting support."

Below the answer, the visitor sees links to the two source articles that information came from. They got a direct answer, they can read the full policy if they want to, and they did not have to trawl through search results guessing which article might be relevant.

A Few things to know before Go Live

The embedding cost for the initial indexing run is usually smaller than people expect. A site with 500 articles at 400 words each, split into chunks of 400 words with 50-word overlap, produces roughly 600 to 700 chunks. At OpenAI's current pricing for text-embedding-3-small, that initial index costs well under a dollar. Ongoing costs per search query are minimal, one embedding call per query.

Caching search results is worth adding early. Many visitors on the same site ask very similar questions. Store recent query-answer pairs in Joomla's cache layer with a TTL of a few hours. The cache hit rate on popular queries tends to be high and it cuts both API costs and response time meaningfully.

Finally, keep an eye on what people actually search for. Log the queries, log whether the similarity search returned results above the threshold, and log whether users clicked the source links. After a few weeks you will see which questions the pipeline handles well and which ones consistently miss. That data tells you whether your chunking strategy needs adjusting, whether your similarity threshold is set correctly, and whether there are content gaps on your site worth addressing.

The RAG pattern is one of the most practically useful things you can add to a content-heavy Joomla site. It turns a search box that frustrates visitors into one that actually helps them find what they need, in their own words, without requiring your content to match their exact phrasing.

Drupal and LangChain: Building Multi-Step AI Pipelines for Enterprise CMS

noreply@blogger.com (PHP CMS Frameworks) — Sat, 28 Mar 2026 13:50:00 +0000

Enterprise content teams have a problem that does not get talked about enough. It is not producing content, most large organisations have plenty of that. The problem is what happens to content before it gets published. Review queues that stretch for days, moderation bottlenecks where one editor is the single point of failure, policy checks that get skipped under deadline pressure, and taxonomy tagging that is inconsistent across a team of twenty people all making their own judgment calls.

I worked with an enterprise Drupal site last year that had over 3,000 pieces of content sitting in a moderation queue at any given time. Four editors, no automation, no triage. Good content was getting buried under low-quality submissions and the editors were spending most of their time on mechanical checks rather than actual editorial judgment.

What they needed was a multi-step AI pipeline sitting between content submission and human review. Something that could screen content automatically, flag policy violations, suggest taxonomy terms, score quality, and route content to the right reviewer based on what it found. That is what this post is about.

We will cover how LangChain fits into a Drupal architecture, the honest tradeoffs between the Python, JavaScript, and PHP approaches, and then go deep on building the full pipeline in PHP inside a custom Drupal module.

Why LangChain matters here

LangChain is a framework for building applications that chain multiple AI calls together, each step taking the output of the previous one as its input. Instead of sending one big prompt to an LLM and hoping for a good result, you break the problem into focused steps. One step checks for policy violations. The next scores content quality. The next suggests taxonomy terms. The next decides where to route the content for review. Each step does one thing well.

The reason this matters for an enterprise CMS is that single-prompt AI approaches get inconsistent quickly when content is varied and complex. A one-shot prompt that tries to check policy compliance, assess quality, tag taxonomy, and make a routing decision all at once tends to produce mediocre results across all four. Breaking it into a chain where each step is focused produces meaningfully better output, and more importantly, it makes each step auditable. You can see exactly where the pipeline flagged something and why.

LangChain was originally built in Python, which is where it is most mature. A JavaScript version called LangChain.js followed. There is no official PHP version, which creates an interesting architecture question for Drupal teams.

Three ways to use LangChain with Drupal

Before picking an approach, it is worth understanding what each option actually involves in practice. I have seen teams choose the wrong one based on familiarity rather than fit, and it costs them later.

Option 1: Python LangChain as a Separate Microservice

You build a small Python FastAPI or Flask service that runs LangChain pipelines. Drupal calls this service via HTTP when content needs processing and receives structured JSON back. The pipeline logic lives entirely in Python, Drupal just sends content and handles the response.

This is the most powerful option because you get the full LangChain Python ecosystem, including document loaders, vector stores, agents, and memory. The tradeoff is operational complexity. You are now running and maintaining two separate services, Python and PHP, and your team needs to be comfortable in both.

Good fit for: teams with Python expertise already on staff, complex pipelines that need LangChain agents or vector retrieval, and organisations with proper infrastructure for running multiple services.

Option 2: LangChain.js via a Node.js Microservice

Similar architecture to Option 1 but the sidecar service runs Node.js with LangChain.js instead of Python. Drupal calls it the same way via HTTP. LangChain.js has caught up significantly to the Python version in recent versions and covers most common pipeline patterns.

The advantage over Python is that JavaScript is more widely known across web development teams. The disadvantage is that LangChain.js still lags behind Python on some advanced features, and you still have the same two-service operational overhead.

Good fit for: teams with frontend JavaScript experience who want to avoid Python, simpler pipeline patterns, and organisations already running Node.js services.

Option 3: PHP Pipeline Mimicking LangChain Patterns (What We Are Building)

You implement the same chaining concepts directly in PHP using the OpenAI PHP client, no LangChain library involved. Each step in the pipeline is a focused PHP class. They chain together through a Pipeline orchestrator. The output of each step feeds into the next.

This approach keeps everything inside Drupal, no additional services to deploy or maintain, no cross-language boundaries, no HTTP overhead between steps. The tradeoff is that you implement the chaining logic yourself rather than using a ready-made framework.

Honestly, for most enterprise Drupal use cases this is the right call. The LangChain library provides a lot of features you will not need for a content moderation pipeline. What you need is the chaining pattern, structured prompts, and reliable JSON outputs, and all of that is straightforward to implement in PHP.

Good fit for: Drupal teams without Python or Node.js expertise, pipelines that do not require vector retrieval or complex agents, and organisations that want the full pipeline inside their existing Drupal infrastructure.

That is the option we are going deep on. Here is what we are building.

The Pipeline We Are Building

Four steps, each focused on one job:

Content submitted to Drupal
        ↓
Step 1: Policy Compliance Check
        Does the content violate any publishing policies?
        Output: pass / flag / reject + reason
        ↓
Step 2: Quality Assessment
        Is the content well-written, complete, and suitable for publishing?
        Output: quality score 1-10 + specific feedback
        ↓
Step 3: Taxonomy Suggestion
        What terms should be applied to this content?
        Output: suggested taxonomy terms with confidence scores
        ↓
Step 4: Routing Decision
        Based on the above, where should this content go?
        Output: auto-approve / send to editor / send to senior editor / reject
        ↓
Content routed to correct moderation state in Drupal

Each step receives the original content plus the outputs of all previous steps. By the time Step 4 runs, it has the policy check result, the quality score, and the taxonomy suggestions available to inform its routing decision. That context is what makes the routing intelligent rather than mechanical.

Setting up the custom Drupal module

We will build this as a custom Drupal module. Create the module structure:

modules/custom/ai_content_pipeline/
    ai_content_pipeline.info.yml
    ai_content_pipeline.services.yml
    ai_content_pipeline.module
    src/
        Pipeline/
            ContentModerationPipeline.php
        Steps/
            PolicyComplianceStep.php
            QualityAssessmentStep.php
            TaxonomySuggestionStep.php
            RoutingDecisionStep.php
        Contracts/
            PipelineStepInterface.php
        Service/
            OpenAIService.php

The ai_content_pipeline.info.yml:

name: 'AI Content Pipeline'
type: module
description: 'Multi-step AI pipeline for intelligent content moderation'
core_version_requirement: ^10 || ^11
package: Custom
dependencies:
  - drupal:node

Install the OpenAI PHP client via Composer in your Drupal project root:

composer require openai-php/client

Step 1: The Pipeline step interface

Every step in the pipeline implements this interface. It enforces a consistent contract across all steps, which makes the pipeline orchestrator simple to write and easy to extend with new steps later.

Create src/Contracts/PipelineStepInterface.php:

<?php

namespace Drupal\ai_content_pipeline\Contracts;

interface PipelineStepInterface
{
    /**
     * Execute this pipeline step.
     *
     * @param string $content  The original content being processed.
     * @param array  $context  Results from all previous steps.
     *
     * @return array  Results from this step to pass forward.
     */
    public function execute(string $content, array $context): array;

    /**
     * Human-readable name for this step, used in logging.
     */
    public function name(): string;
}

Step 2: The OpenAI Service

Create src/Service/OpenAIService.php:

<?php

namespace Drupal\ai_content_pipeline\Service;

use OpenAI;

class OpenAIService
{
    private $client;

    public function __construct()
    {
        $api_key = \Drupal::config('ai_content_pipeline.settings')->get('openai_api_key');
        $this->client = OpenAI::client($api_key);
    }

    public function chat(string $systemPrompt, string $userMessage): string
    {
        $response = $this->client->chat()->create([
            'model'       => 'gpt-4o',
            'temperature' => 0.2,
            'messages'    => [
                ['role' => 'system', 'content' => $systemPrompt],
                ['role' => 'user',   'content' => $userMessage],
            ],
        ]);

        return $response->choices[0]->message->content;
    }

    public function parseJson(string $raw): array
    {
        $clean = preg_replace('/^```json\s*/i', '', trim($raw));
        $clean = preg_replace('/```$/', '', trim($clean));
        $data  = json_decode(trim($clean), true);

        if (json_last_error() !== JSON_ERROR_NONE) {
            return ['error' => 'JSON parse failed', 'raw' => $raw];
        }

        return $data;
    }
}

The temperature is set to 0.2, lower than you might expect. For pipeline steps that are making structured decisions, you want as little creative variance as possible. The model should be analytical, not inventive.

Step 3: The Policy Compliance step

Create src/Steps/PolicyComplianceStep.php:

<?php

namespace Drupal\ai_content_pipeline\Steps;

use Drupal\ai_content_pipeline\Contracts\PipelineStepInterface;
use Drupal\ai_content_pipeline\Service\OpenAIService;

class PolicyComplianceStep implements PipelineStepInterface
{
    public function __construct(private OpenAIService $ai) {}

    public function name(): string
    {
        return 'Policy Compliance Check';
    }

    public function execute(string $content, array $context): array
    {
        $system = 'You are a content policy compliance reviewer for an enterprise CMS.
                   Review content against publishing policies and return JSON only.
                   No markdown, no explanation outside the JSON object.';

        $prompt = <<<PROMPT
Review the following content against these publishing policies:

1. No hate speech, discrimination, or offensive language targeting any group.
2. No unverified factual claims presented as established fact.
3. No promotional or advertorial content disguised as editorial.
4. No personally identifiable information about private individuals.
5. No content that could create legal liability (defamation, copyright issues).

Return a JSON object with:
- "status": one of "pass", "flag", or "reject"
- "violations": array of specific violations found, empty array if none
- "reason": brief explanation of the status decision

Content to review:
{$content}
PROMPT;

        $raw    = $this->ai->chat($system, $prompt);
        $result = $this->ai->parseJson($raw);

        return [
            'policy' => $result,
        ];
    }
}

Step 4: The Quality Assessment step

Create src/Steps/QualityAssessmentStep.php:

<?php

namespace Drupal\ai_content_pipeline\Steps;

use Drupal\ai_content_pipeline\Contracts\PipelineStepInterface;
use Drupal\ai_content_pipeline\Service\OpenAIService;

class QualityAssessmentStep implements PipelineStepInterface
{
    public function __construct(private OpenAIService $ai) {}

    public function name(): string
    {
        return 'Quality Assessment';
    }

    public function execute(string $content, array $context): array
    {
        $policyStatus = $context['policy']['status'] ?? 'unknown';

        $system = 'You are a senior editorial quality reviewer for an enterprise CMS.
                   Assess content quality objectively and return JSON only.';

        $prompt = <<<PROMPT
Assess the quality of the following content. Consider:

- Clarity and readability for a general professional audience
- Completeness: does it cover the topic adequately?
- Structure: is it well organised with a logical flow?
- Accuracy indicators: does it make claims without apparent support?
- Tone: is it appropriate for professional publication?

Note: Policy compliance status from previous check is "{$policyStatus}".

Return a JSON object with:
- "score": integer from 1 to 10
- "strengths": array of what the content does well
- "weaknesses": array of specific quality issues found
- "publishable": boolean, true if quality is sufficient for publication

Content:
{$content}
PROMPT;

        $raw    = $this->ai->chat($system, $prompt);
        $result = $this->ai->parseJson($raw);

        return [
            'quality' => $result,
        ];
    }
}

Step 5: The Taxonomy Suggestion step

Create src/Steps/TaxonomySuggestionStep.php:

<?php

namespace Drupal\ai_content_pipeline\Steps;

use Drupal\ai_content_pipeline\Contracts\PipelineStepInterface;
use Drupal\ai_content_pipeline\Service\OpenAIService;

class TaxonomySuggestionStep implements PipelineStepInterface
{
    private array $availableTerms = [
        'topics'     => ['Technology', 'Business', 'Health', 'Finance', 'Policy', 'Research', 'Opinion'],
        'audience'   => ['General', 'Technical', 'Executive', 'Academic'],
        'content_type' => ['Analysis', 'News', 'Tutorial', 'Case Study', 'Interview', 'Report'],
    ];

    public function __construct(private OpenAIService $ai) {}

    public function name(): string
    {
        return 'Taxonomy Suggestion';
    }

    public function execute(string $content, array $context): array
    {
        $termsJson = json_encode($this->availableTerms);

        $system = 'You are a content taxonomy specialist for an enterprise CMS.
                   Suggest appropriate taxonomy terms and return JSON only.';

        $prompt = <<<PROMPT
Suggest taxonomy terms for the following content.
Only suggest terms from the available taxonomy list provided.

Available taxonomy terms:
{$termsJson}

Return a JSON object with:
- "suggestions": object with vocabulary names as keys, each containing:
    - "terms": array of suggested term names from the available list
    - "confidence": "high", "medium", or "low"
- "primary_topic": the single most relevant topic term

Content:
{$content}
PROMPT;

        $raw    = $this->ai->chat($system, $prompt);
        $result = $this->ai->parseJson($raw);

        return [
            'taxonomy' => $result,
        ];
    }
}

In a real deployment, replace the hardcoded $availableTerms array with a dynamic lookup from your Drupal taxonomy vocabularies. You can load terms using Drupal's entity query system and pass the full list to the prompt.

Step 6: The Routing Decision step

This is where the pipeline pays off. By the time this step runs, it has the policy result, quality score, and taxonomy confidence from the previous three steps. The routing decision is genuinely informed rather than based on a single signal.

Create src/Steps/RoutingDecisionStep.php:

<?php

namespace Drupal\ai_content_pipeline\Steps;

use Drupal\ai_content_pipeline\Contracts\PipelineStepInterface;
use Drupal\ai_content_pipeline\Service\OpenAIService;

class RoutingDecisionStep implements PipelineStepInterface
{
    public function __construct(private OpenAIService $ai) {}

    public function name(): string
    {
        return 'Routing Decision';
    }

    public function execute(string $content, array $context): array
    {
        $policyStatus   = $context['policy']['status']       ?? 'unknown';
        $policyReason   = $context['policy']['reason']       ?? '';
        $qualityScore   = $context['quality']['score']       ?? 0;
        $publishable    = $context['quality']['publishable']  ?? false;
        $weaknesses     = json_encode($context['quality']['weaknesses'] ?? []);
        $violations     = json_encode($context['policy']['violations']  ?? []);

        $system = 'You are a content workflow manager for an enterprise CMS.
                   Make routing decisions based on pipeline analysis results.
                   Return JSON only.';

        $prompt = <<<PROMPT
Based on the pipeline analysis below, decide how this content should be routed.

Pipeline results:
- Policy status: {$policyStatus}
- Policy reason: {$policyReason}
- Policy violations: {$violations}
- Quality score: {$qualityScore} / 10
- Publishable assessment: {$publishable}
- Quality weaknesses: {$weaknesses}

Routing options:
- "auto_approve": policy passed, quality score 9-10, no issues
- "editor_review": policy passed, quality score 6-8, minor issues only
- "senior_editor_review": policy flagged or quality score 4-5, needs experienced judgment
- "reject": policy status is reject, or quality score below 4

Return a JSON object with:
- "decision": one of the four routing options above
- "reason": clear explanation of why this routing was chosen
- "reviewer_notes": specific things the human reviewer should check, as an array
- "priority": "high", "normal", or "low"
PROMPT;

        $raw    = $this->ai->chat($system, $prompt);
        $result = $this->ai->parseJson($raw);

        return [
            'routing' => $result,
        ];
    }
}

Step 7: The Pipeline Orchestrator

This is the class that wires everything together. It runs each step in sequence, collects the context, handles failures gracefully, and returns the full pipeline result.

Create src/Pipeline/ContentModerationPipeline.php:

<?php

namespace Drupal\ai_content_pipeline\Pipeline;

use Drupal\ai_content_pipeline\Contracts\PipelineStepInterface;
use Drupal\Core\Logger\LoggerChannelFactoryInterface;

class ContentModerationPipeline
{
    private array $steps = [];
    private $logger;

    public function __construct(LoggerChannelFactoryInterface $loggerFactory)
    {
        $this->logger = $loggerFactory->get('ai_content_pipeline');
    }

    public function addStep(PipelineStepInterface $step): self
    {
        $this->steps[] = $step;
        return $this;
    }

    public function run(string $content): array
    {
        $context   = [];
        $stepLog   = [];
        $startTime = microtime(true);

        foreach ($this->steps as $step) {
            $stepName  = $step->name();
            $stepStart = microtime(true);

            try {
                $result  = $step->execute($content, $context);
                $context = array_merge($context, $result);

                $stepLog[] = [
                    'step'     => $stepName,
                    'status'   => 'completed',
                    'duration' => round(microtime(true) - $stepStart, 2) . 's',
                ];

                $this->logger->info('Pipeline step completed: @step', ['@step' => $stepName]);

            } catch (\Exception $e) {
                $this->logger->error('Pipeline step failed: @step, Error: @error', [
                    '@step'  => $stepName,
                    '@error' => $e->getMessage(),
                ]);

                $stepLog[] = [
                    'step'   => $stepName,
                    'status' => 'failed',
                    'error'  => $e->getMessage(),
                ];

                // On failure, route to senior editor for manual review
                $context['routing'] = [
                    'decision'       => 'senior_editor_review',
                    'reason'         => "Pipeline step '{$stepName}' failed. Manual review required.",
                    'reviewer_notes' => ['Pipeline encountered an error, please review manually.'],
                    'priority'       => 'high',
                ];

                break;
            }
        }

        return [
            'context'       => $context,
            'steps'         => $stepLog,
            'total_duration' => round(microtime(true) - $startTime, 2) . 's',
        ];
    }
}

Step 8: Wiring it into Drupal's Moderation workflow

Now we connect the pipeline to Drupal's content workflow. This hook fires when a node is presaved, runs the pipeline, and applies the routing decision as a moderation state.

In ai_content_pipeline.module:

<?php

use Drupal\node\NodeInterface;
use Drupal\ai_content_pipeline\Service\OpenAIService;
use Drupal\ai_content_pipeline\Pipeline\ContentModerationPipeline;
use Drupal\ai_content_pipeline\Steps\PolicyComplianceStep;
use Drupal\ai_content_pipeline\Steps\QualityAssessmentStep;
use Drupal\ai_content_pipeline\Steps\TaxonomySuggestionStep;
use Drupal\ai_content_pipeline\Steps\RoutingDecisionStep;

function ai_content_pipeline_node_presave(NodeInterface $node): void
{
    // Only run on new nodes that are pending moderation
    if (!$node->isNew()) {
        return;
    }

    $content = $node->getTitle() . "\n\n" . $node->get('body')->value;

    if (empty(trim($content))) {
        return;
    }

    $ai       = new OpenAIService();
    $pipeline = new ContentModerationPipeline(\Drupal::service('logger.factory'));

    $pipeline
        ->addStep(new PolicyComplianceStep($ai))
        ->addStep(new QualityAssessmentStep($ai))
        ->addStep(new TaxonomySuggestionStep($ai))
        ->addStep(new RoutingDecisionStep($ai));

    $result   = $pipeline->run($content);
    $routing  = $result['context']['routing'] ?? null;

    if (!$routing) {
        return;
    }

    // Map routing decision to Drupal moderation states
    $stateMap = [
        'auto_approve'         => 'published',
        'editor_review'        => 'needs_review',
        'senior_editor_review' => 'needs_review',
        'reject'               => 'rejected',
    ];

    $decision = $routing['decision'] ?? 'editor_review';
    $state    = $stateMap[$decision] ?? 'needs_review';

    if ($node->hasField('moderation_state')) {
        $node->set('moderation_state', $state);
    }

    // Store pipeline results in a field for reviewer reference
    if ($node->hasField('field_ai_review_notes')) {
        $notes  = "Routing: {$decision}\n";
        $notes .= "Reason: {$routing['reason']}\n\n";
        $notes .= "Reviewer notes:\n" . implode("\n", $routing['reviewer_notes'] ?? []);
        $node->set('field_ai_review_notes', $notes);
    }
}

What the Pipeline output looks like in practice

Here is a realistic example of the full pipeline result for a piece of content that passed policy checks but had quality issues. This is what your editors would see in the review notes field.

{
  "context": {
    "policy": {
      "status": "pass",
      "violations": [],
      "reason": "Content meets all publishing policy requirements."
    },
    "quality": {
      "score": 6,
      "publishable": true,
      "strengths": ["Clear headline", "Good factual grounding"],
      "weaknesses": ["Conclusion is abrupt and underdeveloped", "Second section lacks supporting evidence"]
    },
    "taxonomy": {
      "suggestions": {
        "topics": { "terms": ["Technology", "Business"], "confidence": "high" },
        "audience": { "terms": ["Executive"], "confidence": "medium" },
        "content_type": { "terms": ["Analysis"], "confidence": "high" }
      },
      "primary_topic": "Technology"
    },
    "routing": {
      "decision": "editor_review",
      "reason": "Policy passed but quality score of 6 indicates minor issues that need editorial attention before publication.",
      "reviewer_notes": [
        "Strengthen the conclusion, currently ends abruptly",
        "Add supporting evidence or sources to the second section",
        "Taxonomy auto-applied, verify the Executive audience tag is correct"
      ],
      "priority": "normal"
    }
  },
  "steps": [
    { "step": "Policy Compliance Check", "status": "completed", "duration": "1.8s" },
    { "step": "Quality Assessment",      "status": "completed", "duration": "2.1s" },
    { "step": "Taxonomy Suggestion",     "status": "completed", "duration": "1.6s" },
    { "step": "Routing Decision",        "status": "completed", "duration": "1.4s" }
  ],
  "total_duration": "6.9s"
}

The reviewer opens the content, sees it has been routed to them with a quality score of 6, reads the specific reviewer notes, and knows exactly what to look at. No need to read the whole piece from scratch looking for problems. That is the practical value here.

Things worth knowing before you deploy

Seven seconds of pipeline processing on every content submission is not acceptable for a synchronous save operation. Move the pipeline into a queued job that fires after the initial save, using Drupal's Queue API or a custom queue worker. Store a "pending AI review" state that content sits in while the pipeline runs, then update the moderation state when the job completes.

The system prompts in each step are where the real customisation happens. The policy step above uses generic rules, but for a real enterprise deployment you would replace those with your organisation's actual editorial policies, pulled from a config form or a dedicated policy content type in Drupal itself. That way non-technical editors can update the policy rules without touching code.

On cost, four GPT-4o calls per content submission adds up across a high-volume site. For content that does not need the full pipeline, like very short pieces or resubmissions, consider a lighter first-pass check using GPT-4o-mini before deciding whether to run the full chain. The classification step costs a fraction of the full pipeline and can filter out a significant portion of submissions early.

Finally, keep the pipeline results. Store each step's output against the content revision in a custom table or a long text field. After a few months you will have data on what the pipeline flags most often, how accurate the routing decisions are, and where editors are overriding the AI recommendations. That feedback loop is what lets you improve the system prompts over time and actually measure whether the pipeline is helping.

The pattern here, focused steps, structured JSON outputs, full context passed forward, graceful failure handling, is the same pattern LangChain formalises in its framework. Building it directly in PHP means you keep it inside your existing Drupal infrastructure with no additional services to run. For most enterprise Drupal teams, that is the right tradeoff.

Build a WhatsApp AI Assistant Using Laravel, Twilio and OpenAI

noreply@blogger.com (PHP CMS Frameworks) — Wed, 25 Mar 2026 14:42:00 +0000

A few months ago a client came to us with a pretty common problem. Their support team was spending most of the day answering the same twenty questions over and over. Shipping times, return policies, order status, payment methods. The questions were predictable. The answers were documented. But every single one still needed a human to respond.

They were already using WhatsApp for customer communication, so the ask was simple: can we put something intelligent on that channel so the team can focus on the cases that actually need them? That is how we ended up building a WhatsApp AI assistant using Laravel, Twilio, and OpenAI, and it is exactly what this post covers.

By the end you will have a working bot that receives WhatsApp messages through a Twilio webhook, maintains conversation memory per customer so context carries across messages, and uses OpenAI to generate replies that sound like a real support agent. The whole thing runs on standard Laravel, no exotic packages.

What you need:

Laravel 10 or 11
Twilio account with WhatsApp sandbox access
OpenAI API key
Publicly accessible URL for your webhook

If you are working locally, ngrok handles that last part cleanly.

How the system works before we write any code

It is worth spending a minute on the architecture before jumping in. When a customer sends a WhatsApp message, Twilio receives it and forwards it to your webhook URL as an HTTP POST request. Laravel handles that request, pulls the customer's conversation history from cache, appends the new message, sends the full context to OpenAI, gets a reply, stores the updated history back in cache, and sends the response back to Twilio which delivers it to WhatsApp.

Customer sends WhatsApp message
        ↓
Twilio receives it and POSTs to your Laravel webhook
        ↓
Laravel pulls conversation history from Cache
        ↓
Appends new message to history
        ↓
Sends full conversation context to OpenAI
        ↓
OpenAI returns a support reply
        ↓
Laravel stores updated history in Cache
        ↓
Laravel responds with TwiML so Twilio delivers the message
        ↓
Customer receives the reply on WhatsApp

The conversation memory is the part most tutorials skip. Without it, every message the customer sends is treated as a brand new conversation. The bot has no idea what was just discussed. That makes for a frustrating experience, especially in support scenarios where context matters a lot.

Step 1: Install Laravel and required packages

composer create-project laravel/laravel whatsapp-ai-assistant
cd whatsapp-ai-assistant
composer require openai-php/laravel twilio/sdk

Publish the OpenAI config:

php artisan vendor:publish --provider="OpenAI\Laravel\ServiceProvider"

Add your credentials to .env:

OPENAI_API_KEY=sk-your-openai-key-here

TWILIO_SID=ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
TWILIO_AUTH_TOKEN=your-auth-token-here
TWILIO_WHATSAPP_FROM=whatsapp:+14155238886

The number in TWILIO_WHATSAPP_FROM is Twilio's shared WhatsApp sandbox number. Once you go to production and get a dedicated number approved by WhatsApp, you update it there.

Add the Twilio values to config/services.php so you can access them cleanly throughout the app:

'twilio' => [
    'sid'        => env('TWILIO_SID'),
    'auth_token' => env('TWILIO_AUTH_TOKEN'),
    'from'       => env('TWILIO_WHATSAPP_FROM'),
],

Step 2: The Conversation Memory Service

This is the part that makes the bot actually useful in a support context. Each customer gets their own conversation history stored in Laravel Cache, keyed by their WhatsApp number. Every time they send a message, we load their history, add the new message, send the whole thing to OpenAI, then save the updated history back.

Create app/Services/ConversationMemoryService.php:

<?php

namespace App\Services;

use Illuminate\Support\Facades\Cache;

class ConversationMemoryService
{
    private int $maxMessages = 20;
    private int $ttlMinutes  = 60;

    /**
     * Get conversation history for a given WhatsApp number.
     */
    public function getHistory(string $phone): array
    {
        return Cache::get($this->key($phone), []);
    }

    /**
     * Append a new message to the conversation history.
     */
    public function addMessage(string $phone, string $role, string $content): void
    {
        $history = $this->getHistory($phone);

        $history[] = [
            'role'    => $role,
            'content' => $content,
        ];

        // Keep history trimmed so we do not blow the context window
        if (count($history) > $this->maxMessages) {
            $history = array_slice($history, -$this->maxMessages);
        }

        Cache::put($this->key($phone), $history, now()->addMinutes($this->ttlMinutes));
    }

    /**
     * Clear conversation history, useful for reset commands.
     */
    public function clearHistory(string $phone): void
    {
        Cache::forget($this->key($phone));
    }

    private function key(string $phone): string
    {
        return 'whatsapp_conversation_' . md5($phone);
    }
}

The maxMessages limit of 20 is deliberate. OpenAI has a context window limit and sending an entire day's worth of messages in every request gets expensive fast. Keeping the last 20 exchanges gives the bot enough context to be helpful without unnecessary API cost.

The TTL of 60 minutes means if a customer goes quiet for an hour and comes back, the conversation starts fresh. You can adjust both of these to fit your support workflow.

Step 3: The WhatsApp AI Service

This service handles the OpenAI side. It takes the customer's phone number and their latest message, builds the full conversation context including a system prompt that defines the bot's behaviour, and returns a reply.

Create app/Services/WhatsAppAIService.php:

<?php

namespace App\Services;

use OpenAI\Laravel\Facades\OpenAI;

class WhatsAppAIService
{
    public function __construct(
        private ConversationMemoryService $memory
    ) {}

    public function respond(string $phone, string $userMessage): string
    {
        // Save the customer's message to history first
        $this->memory->addMessage($phone, 'user', $userMessage);

        // Build messages array with system prompt at the top
        $messages = array_merge(
            [$this->systemPrompt()],
            $this->memory->getHistory($phone)
        );

        $response = OpenAI::chat()->create([
            'model'       => 'gpt-4o',
            'temperature' => 0.5,
            'max_tokens'  => 300,
            'messages'    => $messages,
        ]);

        $reply = trim($response->choices[0]->message->content);

        // Save the assistant reply to history so context carries forward
        $this->memory->addMessage($phone, 'assistant', $reply);

        return $reply;
    }

    private function systemPrompt(): array
    {
        return [
            'role'    => 'system',
            'content' => 'You are a friendly and professional customer support assistant
                          for an e-commerce store. You help customers with questions about
                          orders, shipping, returns, and payments. Keep replies concise and
                          clear, ideally under 3 sentences, since this is a WhatsApp conversation.
                          If you do not know something specific about an order, ask the customer
                          for their order number and let them know a human agent will follow up.
                          Never make up order details or policies you are not sure about.',
        ];
    }
}

A few things worth pointing out here. The max_tokens: 300 keeps replies short, which is exactly what you want for WhatsApp. Nobody wants to read a five paragraph response on their phone. The system prompt explicitly tells the bot not to make up order details, which is important for a support context where hallucinated information would cause real problems.

The temperature is 0.5, slightly higher than what I used in the code review bot from the last post. Support responses need to feel natural and conversational, so a bit more variation is fine here.

Step 4: The Webhook Controller

php artisan make:controller WhatsAppWebhookController

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\Response;
use App\Services\WhatsAppAIService;
use App\Services\ConversationMemoryService;

class WhatsAppWebhookController extends Controller
{
    public function __construct(
        private WhatsAppAIService $aiService,
        private ConversationMemoryService $memory
    ) {}

    public function handle(Request $request): Response
    {
        $from    = $request->input('From', '');
        $message = trim($request->input('Body', ''));

        if (empty($from) || empty($message)) {
            return $this->twiml('');
        }

        // Allow customers to reset their conversation
        if (strtolower($message) === 'reset') {
            $this->memory->clearHistory($from);
            return $this->twiml('Conversation reset. How can I help you today?');
        }

        // Handle media messages gracefully
        if ($request->has('MediaUrl0')) {
            return $this->twiml('Thanks for the image. A human agent will review it and get back to you shortly.');
        }

        $reply = $this->aiService->respond($from, $message);

        return $this->twiml($reply);
    }

    /**
     * Build a TwiML response that Twilio uses to send the WhatsApp message.
     */
    private function twiml(string $message): Response
    {
        $xml  = '<?xml version="1.0" encoding="UTF-8"?>';
        $xml .= '<Response>';
        $xml .= '<Message>' . htmlspecialchars($message) . '</Message>';
        $xml .= '</Response>';

        return response($xml, 200)->header('Content-Type', 'text/xml');
    }
}

The reset command is a small touch but worth having. If a customer gets into a confusing exchange and wants to start over, they just send "reset" and the history clears. Useful for testing too.

Step 5: Route and CSRF Exception

Add the webhook route in routes/web.php:

use App\Http\Controllers\WhatsAppWebhookController;

Route::post('/webhook/whatsapp', [WhatsAppWebhookController::class, 'handle'])
    ->name('webhook.whatsapp');

Twilio sends POST requests to your webhook, and Laravel's CSRF middleware will block them by default because Twilio does not send a CSRF token. You need to exclude this route from CSRF protection.

In Laravel 10, open app/Http/Middleware/VerifyCsrfToken.php and add the route to the exceptions array:

<?php

namespace App\Http\Middleware;

use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken as Middleware;

class VerifyCsrfToken extends Middleware
{
    protected $except = [
        'webhook/whatsapp',
    ];
}

In Laravel 11, open bootstrap/app.php and update it there:

->withMiddleware(function (Middleware $middleware) {
    $middleware->validateCsrfTokens(except: [
        'webhook/whatsapp',
    ]);
})

This is one of those things that trips people up the first time they set up a Twilio webhook on Laravel. The request just silently fails and you get no clear error message. If your webhook is not responding, check this before anything else.

Step 6: Validating That Requests Actually Come From Twilio

Since this webhook is publicly accessible, you should verify that incoming requests actually came from Twilio and not from someone who found your endpoint. Twilio signs every request with your auth token and sends the signature in the X-Twilio-Signature header.

Create a middleware to handle this:

php artisan make:middleware ValidateTwilioRequest

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Twilio\Security\RequestValidator;

class ValidateTwilioRequest
{
    public function handle(Request $request, Closure $next): mixed
    {
        $validator = new RequestValidator(config('services.twilio.auth_token'));

        $signature = $request->header('X-Twilio-Signature', '');
        $url       = $request->fullUrl();
        $params    = $request->post();

        if (!$validator->validate($signature, $url, $params)) {
            abort(403, 'Invalid Twilio signature.');
        }

        return $next($request);
    }
}

Apply it to the webhook route:

Route::post('/webhook/whatsapp', [WhatsAppWebhookController::class, 'handle'])
    ->middleware(\App\Http\Middleware\ValidateTwilioRequest::class)
    ->name('webhook.whatsapp');

Skip this during local development if it causes issues. Twilio signature validation depends on the exact URL matching, which can get complicated with ngrok. Enable it in staging and production.

Step 7: Exposing Your Local Server With ngrok

Twilio needs a publicly accessible URL to send webhook requests to. During development, ngrok creates a temporary public tunnel to your local machine. Install it from ngrok.com, then run both of these in separate terminals:

php artisan serve

ngrok http 8000

ngrok will give you a forwarding URL that looks something like https://a1b2c3d4.ngrok.io. Your full webhook URL will be:

https://a1b2c3d4.ngrok.io/webhook/whatsapp

Copy that URL, you will need it in the next step.

Step 8: Configure the Twilio WhatsApp Sandbox

Log into your Twilio console and go to Messaging, then Try it out, then Send a WhatsApp message. You will land on the sandbox configuration page.

Find the field labelled "When a message comes in" and paste your ngrok webhook URL there. Make sure the request method is set to HTTP POST, not GET.

To connect your personal WhatsApp number to the sandbox for testing, send the join code shown on that page (something like "join bright-example") to the Twilio sandbox number on WhatsApp. You will get a confirmation message once you are connected.

Send any message from your WhatsApp now and watch it flow through the full stack.

What a Real Customer Support Conversation Looks Like

Here is an example of the kind of exchange this bot handles well. A customer asking about a return:

Customer : Hi, I want to return a jacket I bought last week

Bot      : Hi there! Happy to help with your return. Could you share your
           order number so I can check the details?

Customer : It is ORDER-48291

Bot      : Thanks! Our standard return window is 30 days from delivery,
           so you are well within that period. Would you like me to walk
           you through the return steps or connect you with a human agent?

Customer : Walk me through it please

Bot      : Sure. Repack the item securely, then visit our returns portal
           and enter your order number to generate a prepaid label. Drop
           it at any courier location and your refund will process within
           3 to 5 business days once we receive it.

Customer : What if I lost the original packaging?

Bot      : No problem at all. Any sturdy box or bag works fine.
           The original packaging is not required for returns.

Four exchanges, the bot carried the order number across messages without the customer repeating it, gave accurate policy information, and offered a clear escalation path. That is exactly what a good first-line support interaction should look like.

Rate Limiting Per Customer

If one customer sends fifty messages in a minute, you do not want to fire fifty OpenAI API calls. Add rate limiting per phone number using Laravel's built-in rate limiter, right at the top of the handle method in your controller:

use Illuminate\Support\Facades\RateLimiter;

$key = 'whatsapp_' . md5($from);

if (RateLimiter::tooManyAttempts($key, 10)) {
    return $this->twiml('You are sending messages too quickly. Please wait a moment and try again.');
}

RateLimiter::hit($key, 60);

This allows 10 messages per minute per customer before the rate limit kicks in. Adjust the numbers based on how your support volume actually looks.

Moving From Sandbox to Production

The sandbox works well for testing but has real limitations. Every customer has to send a join code before the bot can message them, and the sandbox number is shared across all Twilio accounts. For an actual deployment you need a dedicated WhatsApp Business number approved through Meta.

The approval process goes through Twilio's WhatsApp sender registration. You submit your business details, Meta reviews and approves the number, and once that is done you update TWILIO_WHATSAPP_FROM in your production environment and point the webhook to your live URL. The rest of the code does not change.

On the infrastructure side, switch CACHE_DRIVER to redis in production. The file cache works locally but Redis handles concurrent requests from multiple customers properly and survives server restarts without losing conversation history mid-session.

Three things to add before handing this to a Client

The core works well but a production support bot needs a bit more to be truly reliable.

First, a database log of every conversation. Both for debugging and for reviewing what the bot is actually saying to customers. A simple whatsapp_messages table with columns for phone, role, content, and created_at is enough to start. You will thank yourself for having this the first time the bot says something unexpected.

Second, a human handoff trigger. If the customer says something like "I want to speak to a real person" or the bot detects repeated frustration in the conversation, it should stop trying to resolve things automatically and flag the conversation for the support team. A keyword check handles the obvious cases, and you can ask OpenAI to classify sentiment alongside the reply for the subtler ones.

Third, a basic admin view showing active conversations, the most common questions coming in, and average response times. That data is useful for improving the system prompt and for giving the support team visibility into what the bot is handling versus what it is escalating.

Those three additions turn a working prototype into something you can confidently hand over and actually maintain.

Build an AI Code Review Bot with Laravel — Real-World Use Case

noreply@blogger.com (PHP CMS Frameworks) — Sat, 21 Mar 2026 20:35:00 +0000

Let me tell you how this idea actually started. A few months back, our team was doing PR reviews and I kept writing the same comment over and over, something like "this will cause an N+1 issue, please use eager loading." Different developer, different PR, same problem. Third time in two weeks I typed that comment, I thought there has to be a smarter way to handle this first pass.

That is what this is. Not some fancy AI product. Just a practical Laravel tool that takes a PHP code snippet, sends it to OpenAI, and gives back structured feedback before a human reviewer even opens the PR. The idea is simple: catch the obvious stuff automatically so your senior devs can spend their review time on things that actually need a human brain.

I will walk through the full build. By the end you will have a working Laravel app that accepts code, returns severity-tagged issues, security flags, suggestions, and a quality score. We will also hook it up to a queue so the UI does not freeze waiting on the API.

What you need before starting: Laravel 10 or 11, PHP 8.1+, Composer, and an OpenAI API key. That is it.

Why not PHPStan or CodeSniffer?

Because they are rule-based. They catch what they have been told to catch, nothing more.

PHPStan at max level is genuinely good. I use it. But here is the thing, some of the worst bugs in production do not violate a single linting rule. An N+1 query loop is syntactically perfect. A function that silently returns null on failure will not trigger any warning. A missing authorization check on a route will not show up in static analysis at all.

An LLM understands context. It can look at code and say "this will fall apart under load" or "this validation will silently pass null." That is a different category of feedback altogether. Use both, they are not competing with each other.

What Gets Checked	PHPStan / PHPCS	AI Reviewer
Syntax and type errors	Strong	Yes
Coding standards	Strong	Yes
N+1 / query logic problems	No	Yes
Security patterns	Partial	Yes
Architecture suggestions	No	Yes
Explains why something is wrong	No	Yes

How everything fits together

Before touching any code, here is the flow:

Developer submits PHP code via a form
        ↓
Laravel controller validates it
        ↓
CodeReviewService builds a structured prompt
        ↓
OpenAI GPT-4o analyses the code
        ↓
JSON response gets parsed
        ↓
Feedback renders back to the developer

No complex abstractions, no unnecessary packages beyond the OpenAI client. The structure is clean enough that adding features later, storing review history, GitHub webhook triggers, Slack notifications, is straightforward.

Step 1: Install Laravel and the OpenAI Package

composer create-project laravel/laravel ai-code-reviewer
cd ai-code-reviewer
composer require openai-php/laravel

Publish the config file:

php artisan vendor:publish --provider="OpenAI\Laravel\ServiceProvider"

Then open your .env and add your key:

OPENAI_API_KEY=sk-your-key-here
OPENAI_ORGANIZATION=

One thing I will say plainly. I have seen API keys committed to git repos more times than I would like. Double check that .env is in your .gitignore before anything else.

Step 2: Create a Service - CodeReviewService

Third-party API calls belong in a service class. Not in a controller, not in a model. This keeps things testable and means when you want to swap GPT-4o for a different model down the line, you change exactly one file.

Create app/Services/CodeReviewService.php manually:

<?php

namespace App\Services;

use OpenAI\Laravel\Facades\OpenAI;

class CodeReviewService
{
    public function review(string $code): array
    {
        $response = OpenAI::chat()->create([
            'model'       => 'gpt-4o',
            'temperature' => 0.3,
            'messages'    => [
                [
                    'role'    => 'system',
                    'content' => 'You are a senior PHP developer and Laravel architect.
                                  Review PHP code and return feedback as valid JSON only.
                                  No markdown. No explanation outside the JSON object.',
                ],
                [
                    'role'    => 'user',
                    'content' => $this->buildPrompt($code),
                ],
            ],
        ]);

        return $this->parse($response->choices[0]->message->content);
    }

    private function buildPrompt(string $code): string
    {
        return <<<PROMPT
Review the PHP/Laravel code below. Return a JSON object with these keys:

- "summary": 1-2 sentence overall assessment.
- "score": integer 1 to 10 for code quality.
- "issues": array of objects with:
    - "severity": "critical", "warning", or "info"
    - "line_hint": function name or rough location
    - "message": clear explanation of the problem
- "suggestions": array of improvement suggestions as strings.
- "security_flags": array of security concerns, or empty array.

Code:

\`\`\`php
{$code}
\`\`\`
PROMPT;
    }

    private function parse(string $raw): array
    {
        $clean = preg_replace('/^```json\s*/i', '', trim($raw));
        $clean = preg_replace('/```$/', '', trim($clean));

        $data = json_decode(trim($clean), true);

        if (json_last_error() !== JSON_ERROR_NONE) {
            return [
                'summary'        => 'Response could not be parsed. Try submitting again.',
                'score'          => null,
                'issues'         => [],
                'suggestions'    => [],
                'security_flags' => [],
            ];
        }

        return $data;
    }
}

The temperature: 0.3 is intentional. Lower temperature means less randomness, the model stays focused and gives consistent output. For creative writing you would push that higher. For structured technical analysis, you want predictable not creative.

Also notice the parse method strips markdown fences. GPT-4o usually returns clean JSON when you ask for it, but it occasionally wraps the output in backtick fences anyway. This handles that without breaking anything.

Step 3: Controller and Routes

php artisan make:controller CodeReviewController

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Services\CodeReviewService;

class CodeReviewController extends Controller
{
    public function __construct(
        private CodeReviewService $reviewService
    ) {}

    public function index()
    {
        return view('code-review.index');
    }

    public function review(Request $request)
    {
        $request->validate([
            'code' => 'required|string|min:10|max:5000',
        ]);

        $feedback = $this->reviewService->review($request->input('code'));

        return view('code-review.result', compact('feedback'));
    }
}

Add the routes in routes/web.php:

use App\Http\Controllers\CodeReviewController;

Route::get('/code-review', [CodeReviewController::class, 'index'])
    ->name('code-review.index');

Route::post('/code-review', [CodeReviewController::class, 'review'])
    ->name('code-review.review');

Step 4: Blade Views

Keeping these minimal. The styling comes from your existing setup, no need to add anything extra here.

resources/views/code-review/index.blade.php

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>AI Code Reviewer</title>
</head>
<body>

<h1>AI Code Reviewer</h1>
<p>Paste PHP or Laravel code below and get structured feedback instantly.</p>

<form method="POST" action="{{ route('code-review.review') }}">
    @csrf
    <textarea name="code" rows="15" cols="80"
              placeholder="Paste your PHP code here...">{{ old('code') }}</textarea>

    @error('code')
        <p>{{ $message }}</p>
    @enderror

    <br>
    <button type="submit">Review Code</button>
</form>

</body>
</html>

resources/views/code-review/result.blade.php

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Review Result</title>
</head>
<body>

<h1>Code Review Result</h1>

<p>{{ $feedback['summary'] ?? '' }}</p>

@isset($feedback['score'])
    <p><strong>Quality Score: {{ $feedback['score'] }} / 10</strong></p>
@endisset

@if(!empty($feedback['issues']))
    <h2>Issues Found</h2>
    @foreach($feedback['issues'] as $issue)
        <div>
            <strong>[{{ strtoupper($issue['severity']) }}]</strong>
            @if(!empty($issue['line_hint']))
                , {{ $issue['line_hint'] }}
            @endif
            <p>{{ $issue['message'] }}</p>
        </div>
        <hr>
    @endforeach
@else
    <p>No major issues found.</p>
@endif

@if(!empty($feedback['security_flags']))
    <h2>Security Flags</h2>
    <ul>
        @foreach($feedback['security_flags'] as $flag)
            <li>{{ $flag }}</li>
        @endforeach
    </ul>
@endif

@if(!empty($feedback['suggestions']))
    <h2>Suggestions</h2>
    <ul>
        @foreach($feedback['suggestions'] as $s)
            <li>{{ $s }}</li>
        @endforeach
    </ul>
@endif

<p><a href="{{ route('code-review.index') }}">Review another snippet</a></p>

</body>
</html>

Step 5: Queue the API Call, Do not block the UI

GPT-4o usually responds in 2 to 4 seconds for short snippets, sometimes longer. That is not great for a synchronous web request, and on some server configs it will hit a timeout before the response comes back. For any production setup, queue it.

php artisan make:job ProcessCodeReview

<?php

namespace App\Jobs;

use App\Services\CodeReviewService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Cache;

class ProcessCodeReview implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $timeout = 60;
    public int $tries   = 2;

    public function __construct(
        private string $code,
        private string $cacheKey
    ) {}

    public function handle(CodeReviewService $service): void
    {
        $result = $service->review($this->code);
        Cache::put($this->cacheKey, $result, now()->addMinutes(10));
    }
}

Update the controller to dispatch the job and add a polling method:

public function review(Request $request)
{
    $request->validate(['code' => 'required|string|min:10|max:5000']);

    $key = 'review_' . md5($request->input('code') . uniqid());

    ProcessCodeReview::dispatch($request->input('code'), $key);

    return view('code-review.waiting', ['cacheKey' => $key]);
}

public function poll(string $key)
{
    $feedback = Cache::get($key);

    if (!$feedback) {
        return response()->json(['status' => 'pending']);
    }

    return response()->json(['status' => 'done', 'feedback' => $feedback]);
}

For local development, set QUEUE_CONNECTION=sync in your .env and jobs will run immediately without needing a worker. In production use redis or database.

What the bot actually catching: A Real Example

Here is a piece of code I have seen in various forms across different projects. It works. On a test database with ten orders nobody notices anything wrong with it.

<?php

public function getUserOrders($userId)
{
    $orders = DB::table('orders')->where('user_id', $userId)->get();

    foreach ($orders as $order) {
        $items = DB::table('order_items')->where('order_id', $order->id)->get();
        echo $order->id . ': ' . count($items) . ' items<br>';
    }
}

Put this in front of a customer with 400 orders and watch what happens to your database.

Paste that into the reviewer and here is what comes back:

{
  "summary": "Code is functional but has a critical N+1 query problem and bypasses Eloquent entirely. Direct output with echo also breaks MVC separation and makes this code untestable.",
  "score": 3,
  "issues": [
    {
      "severity": "critical",
      "line_hint": "foreach loop, DB::table order_items",
      "message": "N+1 query problem. One database query fires per order inside the loop. With 400 orders that becomes 401 queries. Use Eloquent with eager loading: Order::with('items')->where('user_id', $userId)->get()"
    },
    {
      "severity": "warning",
      "line_hint": "DB::table()",
      "message": "Raw query builder bypasses Eloquent model logic, accessors, and relationships. Switching to Eloquent models makes the code significantly easier to maintain and test."
    },
    {
      "severity": "info",
      "line_hint": "echo statement",
      "message": "Direct output inside a controller or service method violates MVC. Return structured data and handle rendering in the view layer."
    }
  ],
  "suggestions": [
    "Define a hasMany relationship on Order pointing to OrderItem.",
    "Replace DB::table calls with Order::with('items')->where('user_id', $userId)->get()",
    "Return a collection and let Blade handle the output, do not echo from service methods."
  ],
  "security_flags": [
    "$userId passes into a query with no type check or validation. Confirm this is an authenticated, validated integer before it reaches any DB call."
  ]
}

Score of 3, one critical issue, one warning, one info note, and a security flag. All accurate, all actionable. That took under four seconds and it is exactly the kind of feedback that usually takes a few minutes of a senior developer's time to write out properly.

Where this fits in an actual Workflow

I want to be direct about this because I have seen people set up tools like this and then either over-rely on them or drop them after two weeks. The right use here is as a first-pass gate, not a replacement for peer review.

The workflow that actually makes sense: developer opens a PR, the bot triggers via a GitHub webhook, posts its feedback as a comment on the PR, and the human reviewer knows the basics have already been handled. They skip straight to the parts that need real judgment, design decisions, edge cases, whether the approach fits the broader architecture.

That is where this earns its place. Not by replacing review. By removing the repetitive first ten minutes of it.

Few things to know before building this:

The prompt structure matters more than anything else in this whole build. Early versions I tried came back as freeform text, which is hard to work with in a UI. Asking the model to return only JSON with field names you define upfront makes parsing reliable every time. Do not skip that part.

GPT-4o is noticeably better than GPT-3.5 for this kind of task, not just in accuracy but in how it explains problems. "Use eager loading" is less useful than "this fires one query per iteration, here is the exact fix." The difference in API cost is worth it if you are using this on a real codebase.

One more thing. Do not feed entire files in at once, at least not to start. Keep the input focused: a single method, one class, a specific feature. Smaller focused reviews produce better feedback. You can extend the input limit later once you are happy with the output quality.

From here the natural extensions to build are a GitHub webhook integration to trigger reviews on every PR automatically, a review history table to track quality trends over time, custom system prompts per project so the bot reviews against your team's conventions specifically, and Slack notifications when a review completes. None of that is complicated to add on top of what we have built here.

If you found this useful, drop a comment in the comment section.

Building a RAG System in Laravel from Scratch

noreply@blogger.com (PHP CMS Frameworks) — Wed, 18 Mar 2026 21:04:00 +0000

Most RAG tutorials start with "first, sign up for Pinecone." I'm going to skip that entirely. For the majority of Laravel applications, a dedicated vector database is overkill. You already have MySQL. You already have Laravel's queue system. That's enough to build a fully functional retrieval augmented generation pipeline that works well into the tens of thousands of documents.

RAG solves a specific problem. LLMs are trained on general data up to a cutoff date. They know nothing about your application's content, your internal docs, your product knowledge base, or anything else specific to your domain. RAG fixes this by retrieving relevant content from your own data and injecting it into the prompt as context before asking the model to answer. The model stops guessing and starts answering based on what you actually have.

Here is how to build it properly in Laravel.

What We Are Building

A pipeline that does four things:

Accepts documents (articles, pages, PDFs, anything text-based) and stores them with their embeddings
When a user asks a question, converts that question into an embedding
Finds the most semantically similar documents using cosine similarity against your stored embeddings
Feeds those documents as context to GPT and returns a grounded answer

No external services beyond OpenAI. No Docker containers for a vector DB. Just Laravel, MySQL, and two API calls per query.

Requirements

Laravel 10 or 11
PHP 8.1+
MySQL 8.0+
OpenAI API key
Guzzle (ships with Laravel)

Step 1: The Documents Table

    
        php artisan make:migration create_documents_table

    
        public function up(): void
        {
            Schema::create('documents', function (Blueprint $table) {
                $table->id();
                $table->string('title');
                $table->longText('content');
                $table->longText('embedding')->nullable(); // JSON float array
                $table->string('source')->nullable(); // URL, filename, etc.
                $table->timestamps();
            });
        }

    
        php artisan migrate

The embedding column stores a JSON-encoded array of 1536 floats (for text-embedding-3-small). Yes, it's a text column, not a native vector type. MySQL 9 adds vector support but for now JSON in a longText column works fine for most use cases.

Step 2: The Document Model

    
        php artisan make:model Document

    
        namespace App\Models;

        use Illuminate\Database\Eloquent\Model;

        class Document extends Model
        {
            protected $fillable = ['title', 'content', 'embedding', 'source'];

            protected $casts = [
                'embedding' => 'array',
            ];
        }

The embedding cast handles the JSON encoding and decoding automatically. When you set $document->embedding = $vectorArray, Laravel serializes it. When you read it back, you get a PHP array of floats.

Step 3: The Embedding Service

Keep all OpenAI communication in one place. This makes it easy to swap providers later.

    
        php artisan make:service EmbeddingService

    
        namespace App\Services;

        use Illuminate\Support\Facades\Http;

        class EmbeddingService
        {
            private string $apiKey;
            private string $model = 'text-embedding-3-small';

            public function __construct()
            {
                $this->apiKey = config('services.openai.key');
            }

            public function embed(string $text): array
            {
                // Trim to ~8000 tokens to stay within model limits
                $text = mb_substr(strip_tags($text), 0, 32000);

                $response = Http::withToken($this->apiKey)
                    ->post('https://api.openai.com/v1/embeddings', [
                        'model' => $this->model,
                        'input' => $text,
                    ]);

                if ($response->failed()) {
                    throw new \RuntimeException('OpenAI embedding request failed: ' . $response->body());
                }

                return $response->json('data.0.embedding');
            }

            public function cosineSimilarity(array $a, array $b): float
            {
                $dot = 0.0;
                $magA = 0.0;
                $magB = 0.0;

                foreach ($a as $i => $val) {
                    $dot += $val * $b[$i];
                    $magA += $val ** 2;
                    $magB += $b[$i] ** 2;
                }

                $denominator = sqrt($magA) * sqrt($magB);

                return $denominator > 0 ? $dot / $denominator : 0.0;
            }
        }

    
        'openai' => [
            'key' => env('OPENAI_API_KEY'),
        ],

Step 4: Indexing Documents

A command to process documents and store their embeddings. You run this once on existing content, then hook it into your document creation flow going forward.

    
        php artisan make:command IndexDocuments

    
        namespace App\Console\Commands;

        use App\Models\Document;
        use App\Services\EmbeddingService;
        use Illuminate\Console\Command;

        class IndexDocuments extends Command
        {
            protected $signature = 'rag:index {--fresh : Re-index all documents}';
            protected $description = 'Generate and store embeddings for all documents';

            public function handle(EmbeddingService $embedder): int
            {
                $query = Document::query();

                if (!$this->option('fresh')) {
                    $query->whereNull('embedding');
                }

                $documents = $query->get();
                $bar = $this->output->createProgressBar($documents->count());

                foreach ($documents as $doc) {
                    try {
                        $doc->embedding = $embedder->embed($doc->title . "\n\n" . $doc->content);
                        $doc->save();
                        $bar->advance();
                    } catch (\Exception $e) {
                        $this->error("Failed on document {$doc->id}: " . $e->getMessage());
                    }

                    // Respect OpenAI rate limits
                    usleep(200000); // 200ms between requests
                }

                $bar->finish();
                $this->newLine();
                $this->info('Indexing complete.');

                return self::SUCCESS;
            }
        }

Run it:

    
        php artisan rag:index

Notice I'm concatenating title and content before embedding. The title carries a lot of semantic weight and including it improves retrieval accuracy noticeably.

Step 5: The Retrieval Logic

This is the core of RAG. Given a query, find the most relevant documents.

    
        namespace App\Services;

        use App\Models\Document;

        class RetrievalService
        {
            public function __construct(private EmbeddingService $embedder) {}

            public function retrieve(string $query, int $topK = 5, float $threshold = 0.75): array
            {
                $queryVector = $this->embedder->embed($query);
                $documents = Document::whereNotNull('embedding')->get();

                $scored = $documents->map(function (Document $doc) use ($queryVector) {
                    return [
                        'document' => $doc,
                        'score' => $this->embedder->cosineSimilarity($queryVector, $doc->embedding),
                    ];
                })
                ->filter(fn($item) => $item['score'] >= $threshold)
                ->sortByDesc('score')
                ->take($topK)
                ->values();

                return $scored->toArray();
            }
        }

The $threshold of 0.75 filters out loosely related documents. You may need to tune this for your content, lower it if you're getting no results, raise it if you're getting irrelevant ones. Anywhere between 0.70 and 0.85 is usually sensible.

Step 6: The RAG Query Service

This ties retrieval and generation together.

    
        namespace App\Services;

        use Illuminate\Support\Facades\Http;

        class RagService
        {
            public function __construct(
                private RetrievalService $retriever,
                private string $apiKey
            ) {
                $this->apiKey = config('services.openai.key');
            }

            public function ask(string $question): array
            {
                // Step 1: Retrieve relevant documents
                $results = $this->retriever->retrieve($question, topK: 4);

                if (empty($results)) {
                    return [
                        'answer' => 'I could not find relevant information to answer this question.',
                        'sources' => [],
                    ];
                }

                // Step 2: Build context from retrieved docs
                $context = collect($results)
                    ->map(fn($r) => "### {$r['document']->title}\n{$r['document']->content}")
                    ->join("\n\n---\n\n");

                // Step 3: Send to GPT with context
                $response = Http::withToken($this->apiKey)
                    ->post('https://api.openai.com/v1/chat/completions', [
                        'model' => 'gpt-4o-mini',
                        'temperature' => 0.2,
                        'messages' => [
                            [
                                'role' => 'system',
                                'content' => "You are a helpful assistant. Answer questions using only the context provided below. If the answer is not in the context, say so clearly. Do not make up information.\n\nContext:\n{$context}"
                            ],
                            [
                                'role' => 'user',
                                'content' => $question,
                            ]
                        ],
                    ]);

                return [
                    'answer' => $response->json('choices.0.message.content'),
                    'sources' => collect($results)->map(fn($r) => [
                        'title' => $r['document']->title,
                        'source' => $r['document']->source,
                        'score' => round($r['score'], 3),
                    ])->toArray(),
                ];
            }
        }

Two things worth noting here. Temperature is set to 0.2, not the default 0.7. You want deterministic, factual answers when doing RAG, not creative ones. And the system prompt explicitly tells the model to stay within the provided context and admit when it doesn't know. Without that instruction, GPT will hallucinate rather than say "I don't have that information."

Step 7: The Controller

    
        php artisan make:controller RagController

    
        namespace App\Http\Controllers;

        use App\Services\RagService;
        use Illuminate\Http\Request;

        class RagController extends Controller
        {
            public function __construct(private RagService $rag) {}

            public function ask(Request $request)
            {
                $request->validate(['question' => 'required|string|max:500']);

                $result = $this->rag->ask($request->input('question'));

                return response()->json($result);
            }
        }

    
        Route::post('/ask', [RagController::class, 'ask']);

Step 8: Test It

Seed a couple of documents first:

    
        Document::create([
            'title' => 'Laravel Queue Configuration',
            'content' => 'Laravel queues allow you to defer time-consuming tasks...',
            'source' => 'https://laravel.com/docs/queues',
        ]);

Run the indexer:

    
        php artisan rag:index

Then hit the endpoint:

    
        curl -X POST http://your-app.test/api/ask \
            -H "Content-Type: application/json" \
            -d '{"question": "How do I configure Laravel queues?"}'

Response:

    
        {
            "answer": "Laravel queues are configured via the config/queue.php file...",
            "sources": [
                {
                "title": "Laravel Queue Configuration",
                "source": "https://laravel.com/docs/queues",
                "score": 0.891
                }
            ]
        }

Where This Falls Down at Scale

This setup works well up to roughly 50,000 documents. Beyond that, loading all embeddings into memory for comparison becomes a problem. At that point your options are:

Add a MySQL generated column + raw SQL dot product approximation to filter candidates before full cosine comparison
Move to pgvector if you can switch to PostgreSQL, which handles this natively and efficiently
Then and only then consider Pinecone or Weaviate

Most Laravel projects never reach that threshold. Start simple, measure, then scale the storage layer when you actually need to.

What to Build on Top of This

Once the core pipeline is working, the useful next steps are: caching query embeddings so repeated questions don't hit the API twice, chunking long documents into 500-token segments before embedding so retrieval is more granular, adding a feedback mechanism so users can flag bad answers and you can track retrieval quality over time, and per-user conversation history so the model has context across multiple turns.

That is a production-ready RAG foundation in Laravel with no external vector database. The whole thing is maybe 200 lines of actual PHP spread across four service classes and one command.

AI SEO Content Quality Analyzer for WordPress Using PHP and OpenAI

noreply@blogger.com (PHP CMS Frameworks) — Tue, 27 Jan 2026 13:56:00 +0000

I've used Yoast and Rank Math for years. Both are solid, but they kept telling me what was wrong, keyword density too low, meta too long without ever telling me why the content wasn't ranking. So I built something different.

This tutorial walks through building a WordPress plugin that uses OpenAI to analyze your post content the way a search engine actually thinks about it, checking search intent alignment, content depth, and semantic quality then gives you a score and specific suggestions right inside the post editor.

Once installed, the plugin analyzes each post and:

Analyze the alignment of search intent
Verify the content's completeness
Identify generic or thin sections
Examine the quality of semantic SEO
Make suggestions for headings, FAQs, and enhancements
Give an AI SEO score between 0 and 100.

This is much more advanced than conventional SEO plugins.

Requirements

WordPress 6.x
PHP 8.1+
Composer (optional)
An OpenAI API key
Basic WordPress plugin development knowledge

Step 1: Create the WordPress Plugin

Create a new plugin folder:

    
        wp-content/plugins/ai-seo-analyzer/

Create ai-seo-analyzer.php

    
        /**
        * Plugin Name: AI SEO Content Quality Analyzer
        * Description: Analyzes WordPress content quality using AI and provides SEO recommendations.
        * Version: 1.0.0
        * Author: phpcmsframework.com
        */

        if (!defined('ABSPATH')) exit;

Activate the plugin from WP Admin → Plugins.

Step 2: Add Meta Box in Post Editor

    
        add_action('add_meta_boxes', function () {
            add_meta_box(
                'ai_seo_box',
                'AI SEO Content Analyzer',
                'ai_seo_meta_box',
                ['post', 'page'],
                'side',
                'high'
            );
        });

        function ai_seo_meta_box($post)
        {
            echo '<button class="button button-primary" id="ai-seo-analyze">Analyze Content</button>';
            echo '<div id="ai-seo-result" style="margin-top:10px;"></div>';
        }

Step 3: AJAX Handler (PHP Only)

    
        add_action('wp_ajax_ai_seo_analyze', 'ai_seo_analyze');

        function ai_seo_analyze()
        {
            $postId = intval($_POST['post_id']);
            $post = get_post($postId);

            if (!$post) {
                wp_send_json_error('Post not found');
            }

            $analysis = ai_seo_analyze_content($post->post_title, $post->post_content);

            wp_send_json_success($analysis);
        }

Step 4: AI Content Analysis Function

    
        function ai_seo_analyze_content($title, $content)
        {
            $prompt = "
        Analyze the SEO quality of the following content.

        Return JSON with:
        - seo_score (0-100)
        - intent_match (Good/Average/Poor)
        - strengths (list)
        - weaknesses (list)
        - improvement_suggestions (list)
        - suggested_headings
        - suggested_faqs

        Title:
        $title

        Content:
        " . strip_tags($content);

            $payload = [
                'model' => 'gpt-4o-mini',
                'messages' => [
                    ['role' => 'system', 'content' => 'You are an expert SEO auditor.'],
                    ['role' => 'user', 'content' => $prompt]
                ],
                'temperature' => 0.2
            ];

            $ch = curl_init('https://api.openai.com/v1/chat/completions');
            curl_setopt_array($ch, [
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_HTTPHEADER => [
                    'Content-Type: application/json',
                    'Authorization: Bearer ' . getenv('OPENAI_API_KEY')
                ],
                CURLOPT_POST => true,
                CURLOPT_POSTFIELDS => json_encode($payload)
            ]);

            $response = json_decode(curl_exec($ch), true);
            curl_close($ch);

            return json_decode($response['choices'][0]['message']['content'], true);
        }

Step 5: JavaScript for Admin UI

    
        add_action('admin_footer', function () {
        ?>
        <script>
        jQuery(function ($) {
            $('#ai-seo-analyze').on('click', function () {
                $('#ai-seo-result').html('Analyzing...');
                $.post(ajaxurl, {
                    action: 'ai_seo_analyze',
                    post_id: $('#post_ID').val()
                }, function (res) {
                    if (res.success) {
                        let r = res.data;
                        $('#ai-seo-result').html(`
                            <strong>SEO Score:</strong> ${r.seo_score}/100<br><br>
                            <strong>Strengths:</strong><ul>${r.strengths.map(i => `<li>${i}</li>`).join('')}</ul>
                            <strong>Weaknesses:</strong><ul>${r.weaknesses.map(i => `<li>${i}</li>`).join('')}</ul>
                        `);
                    } else {
                        $('#ai-seo-result').html('Error analyzing content.');
                    }
                });
            });
        });
        
        <?php
        });

How It Works (Editor View)

Open any post or page
Click “Analyze Content”
AI reviews search intent, depth, structure
You get a quality score + fixes
Update content → re-analyze

Smart Enhancements You Can Add

Compare against top-ranking competitor URLs
Detect keyword stuffing vs natural language
Analyze internal linking opportunities
Auto-generate missing sections
Save score history per post
Bulk audit via WP-CLI

Security & Performance Notes

Store API key in wp-config.php
Limit analysis frequency
Strip shortcodes before sending content
Cache analysis results
Use nonces for AJAX calls in production

AI Duplicate Content Detector for Symfony Using PHP and OpenAI Embeddings

noreply@blogger.com (PHP CMS Frameworks) — Mon, 29 Dec 2025 14:38:00 +0000

If you've been running a Symfony-based blog or CMS for a while, chances are you already have duplicate content. You just don't know it yet. Editors rewrite old articles, documentation pages grow organically, and over time you end up with five pages that all basically say the same thing, just worded differently.

The usual approach to catching this, string matching or exact text comparison, falls apart the moment someone changes a few words. Two articles can be 90% the same in meaning and a simple diff won't flag either of them.

That's where OpenAI embeddings come in. Instead of comparing words, we compare meaning. In this tutorial, I'll show you how to build a duplicate content detector in Symfony that uses vector embeddings and cosine similarity to catch semantically similar articles, even when the wording is completely different..

What We're Constructing

After completing this guide, you will have:

AI-produced embeddings for every article
A cosine similarity-based semantic similarity checker
A command for the console to find duplicates
A threshold for similarity (e.g., 85%+) to mark content
Any Symfony CMS can be integrated with this foundation.

This is effective for:

Blogs
Knowledge bases
Portals for documentation
Pages with e-commerce content

Requirements

Symfony 6 or 7
PHP 8.1+
Doctrine ORM
MySQL / PostgreSQL
An OpenAI API key

Step 1: Add an Embedding Column to Your Entity

Assume an Article entity.

src/Entity/Article.php

    
        #[ORM\Column(type: 'json', nullable: true)]
        private ?array $embedding = null;

        public function getEmbedding(): ?array
        {
            return $this->embedding;
        }

        public function setEmbedding(?array $embedding): self
        {
            $this->embedding = $embedding;
            return $this;
        }

Create and run migration:

    
        php bin/console make:migration
        php bin/console doctrine:migrations:migrate

Step 2: Generate Embeddings for Articles

Create a Symfony command:

    
        php bin/console make:command app:generate-article-embeddings

GenerateArticleEmbeddingsCommand.php

    
        namespace App\Command;

        use App\Entity\Article;
        use Doctrine\ORM\EntityManagerInterface;
        use Symfony\Component\Console\Command\Command;
        use Symfony\Component\Console\Input\InputInterface;
        use Symfony\Component\Console\Output\OutputInterface;

        class GenerateArticleEmbeddingsCommand extends Command
        {
            protected static $defaultName = 'app:generate-article-embeddings';

            public function __construct(
                private EntityManagerInterface $em,
                private string $apiKey
            ) {
                parent::__construct();
            }

            protected function execute(InputInterface $input, OutputInterface $output): int
            {
                $articles = $this->em->getRepository(Article::class)->findAll();

                foreach ($articles as $article) {
                    if ($article->getEmbedding()) {
                        continue;
                    }

                    $embedding = $this->getEmbedding(
                        strip_tags($article->getContent())
                    );

                    $article->setEmbedding($embedding);
                    $this->em->persist($article);

                    $output->writeln("Embedding generated for article ID {$article->getId()}");
                }

                $this->em->flush();
                return Command::SUCCESS;
            }

            private function getEmbedding(string $text): array
            {
                $payload = [
                    'model' => 'text-embedding-3-small',
                    'input' => mb_substr($text, 0, 4000)
                ];

                $ch = curl_init('https://api.openai.com/v1/embeddings');
                curl_setopt_array($ch, [
                    CURLOPT_RETURNTRANSFER => true,
                    CURLOPT_HTTPHEADER => [
                        "Content-Type: application/json",
                        "Authorization: Bearer {$this->apiKey}"
                    ],
                    CURLOPT_POST => true,
                    CURLOPT_POSTFIELDS => json_encode($payload)
                ]);

                $response = curl_exec($ch);
                curl_close($ch);

                return json_decode($response, true)['data'][0]['embedding'] ?? [];
            }
        }

Store the API key in .env.local

    
        OPENAI_API_KEY=your_key_here

Step 3: Cosine Similarity Helper

Create a reusable helper.

src/Service/SimilarityService.php

    
        namespace App\Service;

        class SimilarityService
        {
            public function cosine(array $a, array $b): float
            {
                $dot = 0;
                $magA = 0;
                $magB = 0;

                foreach ($a as $i => $val) {
                    $dot += $val * $b[$i];
                    $magA += $val ** 2;
                    $magB += $b[$i] ** 2;
                }

                return $dot / (sqrt($magA) * sqrt($magB));
            }
        }

Step 4: Detect Duplicate Articles

Create another command:

    
        php bin/console make:command app:detect-duplicates

DetectDuplicateContentCommand.php

    
        namespace App\Command;

        use App\Entity\Article;
        use App\Service\SimilarityService;
        use Doctrine\ORM\EntityManagerInterface;
        use Symfony\Component\Console\Command\Command;
        use Symfony\Component\Console\Input\InputInterface;
        use Symfony\Component\Console\Output\OutputInterface;

        class DetectDuplicateContentCommand extends Command
        {
            protected static $defaultName = 'app:detect-duplicates';

            public function __construct(
                private EntityManagerInterface $em,
                private SimilarityService $similarity
            ) {
                parent::__construct();
            }

            protected function execute(InputInterface $input, OutputInterface $output): int
            {
                $articles = $this->em->getRepository(Article::class)->findAll();
                $threshold = 0.85;

                foreach ($articles as $i => $a) {
                    foreach ($articles as $j => $b) {
                        if ($j <= $i) continue;
                        if (!$a->getEmbedding() || !$b->getEmbedding()) continue;

                        $score = $this->similarity->cosine(
                            $a->getEmbedding(),
                            $b->getEmbedding()
                        );

                        if ($score >= $threshold) {
                            $output->writeln(
                                sprintf(
                                    "⚠ Duplicate detected (%.2f): Article %d and %d",
                                    $score,
                                    $a->getId(),
                                    $b->getId()
                                )
                            );
                        }
                    }
                }

                return Command::SUCCESS;
            }
        }

Step 5: Run via Cron (Optional)

To scan regularly, add a cron job:

    
        0 2 * * * php /path/to/project/bin/console app:detect-duplicates

You can store results in a table or send email notifications.

Example Output

    
        Duplicate detected (0.91): Article 12 and 37
        Duplicate detected (0.88): Article 18 and 44

Useful Improvements

This system can be expanded with:

Admin UI for reviewing duplicates
Canonical page suggestions automatically
Weighting of the title and excerpt
Similarity detection at the section level
Using Messenger for batch processing
Large-scale vector databases

Cost & Performance Advice

Create embeddings for each article only once.
Before embedding, limit the length of the content.
Ignore the draft content
Cache similarity findings
For big datasets, use queues.

AI Category Recommendation System for Drupal 11 Using PHP and OpenAI

noreply@blogger.com (PHP CMS Frameworks) — Tue, 23 Dec 2025 05:49:00 +0000

Categorization in Drupal is one of those things that looks fine on the surface but gets messy fast. Editors are busy, categories get picked in a hurry, and before long you've got a dozen articles filed under the wrong taxonomy term or spread inconsistently across three different ones that mean almost the same thing.

The fix isn't enforcing stricter rules on editors. It's removing the guesswork entirely.

In this tutorial, I'll walk you through building a custom Drupal 11 module that reads a node's actual content and uses OpenAI to pick the most appropriate category automatically, no manual selection needed.

It hooks into the node save process, pulls your existing taxonomy terms, and asks the AI to match the content against them. The result gets assigned before the node is stored. It's a small module but it solves a real problem, especially on sites with large editorial teams or high publishing volume.

What This Module Will Do

Our AI category system will:

Analyze node body content on save
Compare it against existing taxonomy terms
Recommend the most relevant category
Automatically assign it (or display it to editors)

Use cases include:

Blog posts
Documentation pages
News articles
Knowledge bases

Prerequisites

Make sure you have:

Drupal 11
PHP 8.1+
Composer
A taxonomy vocabulary (example: categories)
An OpenAI API key

Step 1: Create the Custom Module

Create a new folder:

    
        /modules/custom/ai_category/

Inside it, create the below files:

ai_category.info.yml
ai_category.module

ai_category.info.yml

    
        name: AI Category Recommendation
        type: module
        description: Automatically recommend and assign taxonomy categories using AI.
        core_version_requirement: ^11
        package: Custom
        version: 1.0.0

Step 2: Hook Into Node Save

We’ll use hook_entity_presave() to analyze content before it’s stored.

ai_category.module

    
        use Drupal\Core\Entity\EntityInterface;
        use Drupal\taxonomy\Entity\Term;

        /**
        * Implements hook_entity_presave().
        */
        function ai_category_entity_presave(EntityInterface $entity) {
            if ($entity->getEntityTypeId() !== 'node') {
                return;
            }

            // Only apply to articles (adjust as needed)
            if ($entity->bundle() !== 'article') {
                return;
            }

            $body = $entity->get('body')->value ?? '';
            if (empty($body)) {
                return;
            }

            $category = ai_category_recommend_term($body);
            if ($category) {
                $entity->set('field_category', ['target_id' => $category]);
            }
        }

This ensures our logic runs only for specific content types and avoids unnecessary processing.

Step 3: Ask AI for Category Recommendation

We’ll send the node content plus a list of available categories to OpenAI and ask it to pick the best one.

    
        function ai_category_recommend_term(string $text): ?int {
            $apiKey = 'YOUR_OPENAI_API_KEY';
            $endpoint = 'https://api.openai.com/v1/chat/completions';

            $terms = \Drupal::entityTypeManager()
                ->getStorage('taxonomy_term')
                ->loadTree('categories');

            $categoryNames = array_map(fn($t) => $t->name, $terms);

            $prompt = "Choose the best category from this list:\n"
                    . implode(', ', $categoryNames)
                    . "\n\nContent:\n"
                    . strip_tags($text)
                    . "\n\nReturn only the category name.";

            $payload = [
                "model" => "gpt-4o-mini",
                "messages" => [
                ["role" => "system", "content" => "You are a content classification assistant."],
                ["role" => "user", "content" => $prompt]
                ],
                "temperature" => 0
            ];

            $ch = curl_init($endpoint);
            curl_setopt_array($ch, [
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_HTTPHEADER => [
                "Content-Type: application/json",
                "Authorization: Bearer {$apiKey}"
                ],
                CURLOPT_POST => true,
                CURLOPT_POSTFIELDS => json_encode($payload),
                CURLOPT_TIMEOUT => 15
            ]);

            $response = curl_exec($ch);
            curl_close($ch);

            $data = json_decode($response, true);
            $chosen = trim($data['choices'][0]['message']['content'] ?? '');

            foreach ($terms as $term) {
                if (strcasecmp($term->name, $chosen) === 0) {
                return $term->tid;
                }
            }

            return null;
        }

What’s happening here:

Drupal loads all available categories
AI receives both content + allowed categories
AI returns one matching category name
Drupal maps it back to a taxonomy term ID

Step 4: Enable the Module

Place the module in /modules/custom/ai_category
Go to Extend → Enable module
Enable AI Category Recommendation
That’s it — no UI needed yet.

Step 5: Test It

Create a new Article
Write content related to PHP, Drupal, AI, or CMS topics
Click Save
The Category field is auto-filled

Example:

Article content:


            “This tutorial explains how to build a custom Drupal 11 module using PHP hooks…”

AI-selected category:

    
        Drupal

Optional Enhancements

Once the basics work, you can extend this system:

Show AI recommendation as a suggestion, not auto-assignment
Add admin settings (API key, confidence threshold)
Use Queue API for bulk classification
Switch to embeddings for higher accuracy
Log category confidence scores
Support multi-term assignment

Security & Performance Tips

Never hard-code API keys (use settings.php or environment variables)
Limit text length before sending to AI
Cache recommendations to reduce API calls
Add fallbacks if the AI response is invalid

AI Auto-Tagging in Laravel Using OpenAI Embeddings + Cron Jobs

noreply@blogger.com (PHP CMS Frameworks) — Tue, 09 Dec 2025 13:21:00 +0000

Manually tagging blog posts works fine when you have ten articles. At a hundred, it gets inconsistent. At a thousand, it's basically broken. Tags get applied differently depending on who wrote the post, and over time your taxonomy becomes a mess that's hard to search and harder to maintain.

I wanted a way to fix this without retagging everything by hand. The approach I landed on uses OpenAI embeddings to represent both post content and tag names as vectors, then assigns tags based on how closely they match in meaning.

The whole thing runs as a Laravel queue job triggered by a cron, so new posts get tagged automatically without any manual step.

In this tutorial I'll walk you through the full setup: generating tag vectors, storing post embeddings, running the cosine similarity match, and wiring it all together with Laravel's scheduler.

What We're Constructing

You'll construct:

Table of Tag Vector - The meaning of each tag (such as "PHP", "Laravel", "Security", and "AI") will be represented by an embedding vector created by AI.
A Generator for Post Embedding - We generate an embedding for the post content whenever a new post is saved.
A Matching Algorithm - The system determines which post embeddings are closest by comparing them with tag embeddings.
A Cron Job -The system automatically assigns AI-recommended tags every hour (or on any schedule).

This is ideal for:

Custom blogs made with Laravel
Headless CMS configurations
Tagging categories in e-commerce
Auto-classification of knowledge bases
Websites for documentation

Now let's get started.

Step 1: Create Migration for Tag Embeddings

Run:

php artisan make:migration create_tag_embeddings_table

Migration:


    public function up()
    {
        Schema::create('tag_embeddings', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('tag_id')->unique();
            $table->json('embedding'); // store vector
            $table->timestamps();
        });
    }

Run:

php artisan migrate

Step 2: Generate Embeddings for Tags

Create a command:

php artisan make:command GenerateTagEmbeddings

Add logic:

    
        public function handle()
        {
            $tags = Tag::all();

            foreach ($tags as $tag) {
                $vector = $this->embed($tag->name);

                TagEmbedding::updateOrCreate(
                    ['tag_id' => $tag->id],
                    ['embedding' => json_encode($vector)]
                );

                $this->info("Embedding created for tag: {$tag->name}");
            }
        }

        private function embed($text)
        {
            $client = new \GuzzleHttp\Client();

            $response = $client->post("https://api.openai.com/v1/embeddings", [
                "headers" => [
                    "Authorization" => "Bearer " . env('OPENAI_API_KEY'),
                    "Content-Type" => "application/json",
                ],
                "json" => [
                    "model" => "text-embedding-3-large",
                    "input" => $text
                ]
            ]);

            $data = json_decode($response->getBody(), true);

            return $data['data'][0]['embedding'] ?? [];
        }

Run once:

php artisan generate:tag-embeddings

Now all tags have AI meaning vectors.

Step 3: Save Embeddings for Each Post

Add to your Post model observer or event.

    
        $post->embedding = $this->embed($post->content);
        $post->save();

Migration for posts:

    
        $table->json('embedding')->nullable();

Step 4: Matching Algorithm (Post → Tags)

Create a helper class:

    
        class EmbeddingHelper
        {
            public static function cosineSimilarity($a, $b)
            {
                $dot = array_sum(array_map(fn($i, $j) => $i * $j, $a, $b));
                $magnitudeA = sqrt(array_sum(array_map(fn($i) => $i * $i, $a)));
                $magnitudeB = sqrt(array_sum(array_map(fn($i) => $i * $i, $b)));
                return $dot / ($magnitudeA * $magnitudeB);
            }
        }

Step 5: Assign Tags Automatically (Queue Job)

Create job:

php artisan make:job AutoTagPost

Job logic:

    
        public function handle()
        {
            $postEmbedding = json_decode($this->post->embedding, true);

            $tags = TagEmbedding::with('tag')->get();

            $scores = [];
            foreach ($tags as $te) {
                $sim = EmbeddingHelper::cosineSimilarity(
                    $postEmbedding,
                    json_decode($te->embedding, true)
                );
                $scores[$te->tag->id] = $sim;
            }

            arsort($scores); // highest similarity first

            $best = array_slice($scores, 0, 5, true); // top 5 matches

            $this->post->tags()->sync(array_keys($best));
        }

Step 6: Cron Job to Process New Posts

Add to app/Console/Kernel.php:

    
        protected function schedule(Schedule $schedule)
        {
            $schedule->command('ai:autotag-posts')->hourly();
        }

Create command:

php artisan make:command AutoTagPosts

Command logic:

    
        public function handle()
        {
            $posts = Post::whereNull('tags_assigned_at')->get();

            foreach ($posts as $post) {
                AutoTagPost::dispatch($post);
                $post->update(['tags_assigned_at' => now()]);
            }
        }

Now, every hour, Laravel processes all new posts and assigns AI-selected tags.

Step 7: Test the Full Flow

Create tags in admin
Run: php artisan generate:tag-embeddings
Create a new blog post
Cron or queue runs
Post automatically gets AI-selected tags

Useful enhancements

Weight tags by frequency
Use title + excerpt, not full content
Add confidence scores to DB
Auto-create new tags using AI
Add a manual override UI
Cache embeddings for performance
Batch process 1,000+ posts

Building an AI-Powered Product Description Generator in Magento 2 Using PHP & OpenAI

noreply@blogger.com (PHP CMS Frameworks) — Tue, 18 Nov 2025 11:15:00 +0000

I was helping a client clean up their Magento store last month and they had over 400 products with either no description or a copy-pasted manufacturer blurb that was identical across 30 items. Writing them manually was not happening.

So I threw together a quick module that puts a button on the product edit page. You click it, it grabs whatever attributes are already filled in and sends them to OpenAI, and a few seconds later the description fields are populated.

Not perfect every time, but good enough as a starting point that you just edit rather than write from scratch.

This tutorial shows you how I built it. The module itself is pretty lightweight, maybe 6 files total, and it works on Magento 2.4 with PHP 8.1.

What we are going to build

A button in Magento 2 for the admin that says "Generate AI Description"
An AJAX controller that sends product attributes to OpenAI
A description, short description, and meta content made by AI
Automatic insertion into Magento product fields
Optional: button to regenerate to get better results

Requirements

Magento 2.4+
PHP 8.1+
Composer
An OpenAI API key
Basic module development skills

Step 1: Create a Magento Module Skeleton

Create your module folders:

    app/code/AlbertAI/ProductDescription/

Inside it, create registration.php

    use Magento\Framework\Component\ComponentRegistrar;

    ComponentRegistrar::register(
        ComponentRegistrar::MODULE,
        'AlbertAI_ProductDescription',
        __DIR__
    );

Then create etc/module.xml

    <?xml version="1.0"?>
    <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
        <module name="AlbertAI_ProductDescription" setup_version="1.0.0"/>
    </config>

Enable the module:

    php bin/magento setup:upgrade

Step 2: On the Product Edit Page, add a button that says "Generate Description."

Create a file: view/adminhtml/layout/catalog_product_edit.xml

    <?xml version="1.0"?>
    <page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">

        <body>
            <referenceBlock name="product_form">
                <block class="AlbertAI\ProductDescription\Block\Adminhtml\GenerateButton"
                    name="ai_description_button"/>
            </referenceBlock>
        </body>
    </page>

Step 3: Create the Admin Button Block

File: Block/Adminhtml/GenerateButton.php

    namespace AlbertAI\ProductDescription\Block\Adminhtml;

    use Magento\Backend\Block\Template;

    class GenerateButton extends Template
    {
        protected $_template = 'AlbertAI_ProductDescription::button.phtml';
    }

Step 4: The Button Markup

File: view/adminhtml/templates/button.phtml

    <button id="ai-generate-btn" class="action-default scalable primary">
        Generate AI Description
    </button>

    <script>
    require(['jquery'], function ($) {
        $('#ai-generate-btn').click(function () {
            const productId = $('#product_id').val();

            $.ajax({
                url: 'getUrl("ai/generator/description") ?>',
                type: 'POST',
                data: { product_id: productId },
                success: function (res) {
                    if (res.success) {
                        $('#description').val(res.description);
                        $('#short_description').val(res.short_description);
                        $('#meta_description').val(res.meta_description);
                        alert("AI description ready!");
                    } else {
                        alert("Error: " + res.error);
                    }
                }
            });
        });
    });
    </script>

Step 5: Create an Admin Route

File: etc/adminhtml/routes.xml

    <?xml version="1.0"?>
    <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="urn:magento:framework:App/etc/routes.xsd">

        <router id="admin">
            <route id="ai" frontName="ai">
                <module name="AlbertAI_ProductDescription"/>
            </route>
        </router>
    </config>

Step 6: Build the AI Controller That Calls OpenAI

File: Controller/Adminhtml/Generator/Description.php

    namespace AlbertAI\ProductDescription\Controller\Adminhtml\Generator;

    use Magento\Backend\App\Action;
    use Magento\Catalog\Api\ProductRepositoryInterface;
    use Magento\Framework\Controller\Result\JsonFactory;

    class Description extends Action
    {
        protected $jsonFactory;
        protected $productRepo;
        private $apiKey = "YOUR_OPENAI_API_KEY";

        public function __construct(
            Action\Context $context,
            ProductRepositoryInterface $productRepo,
            JsonFactory $jsonFactory
        ) {
            parent::__construct($context);
            $this->productRepo = $productRepo;
            $this->jsonFactory = $jsonFactory;
        }

        public function execute()
        {
            $result = $this->jsonFactory->create();

            $id = $this->getRequest()->getParam('product_id');
            if (!$id) {
                return $result->setData(['success' => false, 'error' => 'Product not found']);
            }

            $product = $this->productRepo->getById($id);

            $prompt = sprintf(
                "Write an SEO-friendly product description.\nProduct Name: %s\nBrand: %s\nFeatures: %s\nOutput: Long description, short description, and meta description.",
                $product->getName(),
                $product->getAttributeText('manufacturer'),
                implode(', ', $product->getAttributes())
            );

            $generated = $this->generateText($prompt);

            return $result->setData([
                'success' => true,
                'description' => $generated['long'],
                'short_description' => $generated['short'],
                'meta_description' => $generated['meta']
            ]);
        }

        private function generateText($prompt)
        {
            $body = [
                "model" => "gpt-4.1-mini",
                "messages" => [
                    ["role" => "user", "content" => $prompt]
                ]
            ];

            $ch = curl_init("https://api.openai.com/v1/chat/completions");
            curl_setopt_array($ch, [
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_HTTPHEADER => [
                    "Content-Type: application/json",
                    "Authorization: Bearer " . $this->apiKey
                ],
                CURLOPT_POST => true,
                CURLOPT_POSTFIELDS => json_encode($body)
            ]);
            $response = json_decode(curl_exec($ch), true);
            curl_close($ch);

            $text = $response['choices'][0]['message']['content'] ?? "No response";

            // Split via sections
            return [
                'long' => $this->extract($text, 'Long'),
                'short' => $this->extract($text, 'Short'),
                'meta' => $this->extract($text, 'Meta')
            ];
        }

        private function extract($text, $type)
        {
            preg_match("/$type Description:\s*(.+)/i", $text, $m);
            return $m[1] ?? $text;
        }
    }

Step 7: Test It

Go to Magento Admin → Catalog → Products
Edit any product
Click “Generate AI Description”
Descriptions fields will auto-fill in seconds

Bonus Tips

You can extend the module to generate:

Product titles
Bullet points
FAQ sections
Meta keywords
Category descriptions

AI-Powered Semantic Search in Symfony Using PHP and OpenAI Embeddings

noreply@blogger.com (PHP CMS Frameworks) — Mon, 10 Nov 2025 14:46:00 +0000

LIKE/MATCH queries have a hard ceiling. I've seen Symfony projects where the client kept complaining that search "doesn't work" and the real issue was never the code, it was that users don't search the way you index. They type "how to reset password" and your database has an article titled "Account Recovery Guide." Zero overlap, zero results.

Switching to OpenAI embeddings fixes this at the architecture level. Instead of matching strings, you convert both the query and your content into vectors and measure how close they are in meaning.

A 1536-dimension float array per article sounds heavy but in practice it's stored as JSON in a text column and the whole thing runs fine on a standard MySQL setup for sites with a few thousand articles.

This tutorial wires it up in Symfony using a console command to generate embeddings and a controller endpoint to run the search. No external vector database needed to get started.

Prerequisites

Before we start, make sure you have:

Symfony 6 or 7
PHP 8.1+
Composer
A MySQL or SQLite database
An OpenAI API key

Step 1: Create a New Symfony Command

We’ll use a console command to generate embeddings for your existing content (articles, pages, etc.).

Inside your Symfony project, run:

php bin/console make:command app:generate-embeddings

This will create a new file in src/Command/GenerateEmbeddingsCommand.php.

Replace its contents with the following:

src/Command/GenerateEmbeddingsCommand.php

namespace App\Command;

use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Doctrine\ORM\EntityManagerInterface;
use App\Entity\Article;

#[AsCommand(
    name: 'app:generate-embeddings',
    description: 'Generate AI embeddings for all articles'
)]
class GenerateEmbeddingsCommand extends Command
{
    private $em;
    private $apiKey = 'YOUR_OPENAI_API_KEY';
    private $endpoint = 'https://api.openai.com/v1/embeddings';

    public function __construct(EntityManagerInterface $em)
    {
        $this->em = $em;
        parent::__construct();
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $articles = $this->em->getRepository(Article::class)->findAll();
        foreach ($articles as $article) {
            $embedding = $this->getEmbedding($article->getContent());
            if ($embedding) {
                $article->setEmbedding(json_encode($embedding));
                $this->em->persist($article);
                $output->writeln("✅ Generated embedding for article ID {$article->getId()}");
            }
        }

        $this->em->flush();
        return Command::SUCCESS;
    }

    private function getEmbedding(string $text): ?array
    {
        $payload = [
            'model' => 'text-embedding-3-small',
            'input' => $text,
        ];

        $ch = curl_init($this->endpoint);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                "Content-Type: application/json",
                "Authorization: Bearer {$this->apiKey}"
            ],
            CURLOPT_POST => true,
            CURLOPT_POSTFIELDS => json_encode($payload)
        ]);

        $response = curl_exec($ch);
        curl_close($ch);

        $data = json_decode($response, true);
        return $data['data'][0]['embedding'] ?? null;
    }
}

This command takes every article from the database, sends its content to OpenAI’s Embedding API, and saves the resulting vector in a database field.

Step 2: Update the Entity

Assume your entity is App\Entity\Article.

We’ll add a new column called embedding to store the vector data.

src/Entity/Article.php

    #[ORM\Column(type: 'text', nullable: true)]
    private ?string $embedding = null;

    public function getEmbedding(): ?string
    {
        return $this->embedding;
    }

    public function setEmbedding(?string $embedding): self
    {
        $this->embedding = $embedding;
        return $this;
    }

Then update your database:

    php bin/console make:migration
    php bin/console doctrine:migrations:migrate

Step 3: Create a Search Endpoint

We'll now include a basic controller that takes a search query, turns it into an embedding, and determines which article is the most semantically similar.

src/Controller/SearchController.php

    namespace App\Controller;

    use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
    use Symfony\Component\HttpFoundation\Request;
    use Symfony\Component\HttpFoundation\Response;
    use Symfony\Component\Routing\Annotation\Route;
    use Doctrine\ORM\EntityManagerInterface;
    use App\Entity\Article;

    class SearchController extends AbstractController
    {
        private $apiKey = 'YOUR_OPENAI_API_KEY';
        private $endpoint = 'https://api.openai.com/v1/embeddings';

        #[Route('/search', name: 'ai_search')]
        public function search(Request $request, EntityManagerInterface $em): Response
        {
            $query = $request->query->get('q');
            if (!$query) {
                return $this->json(['error' => 'Please provide a search query']);
            }

            $queryVector = $this->getEmbedding($query);
            $articles = $em->getRepository(Article::class)->findAll();

            $results = [];
            foreach ($articles as $article) {
                if ($article->getEmbedding()) {
                    $score = $this->cosineSimilarity(
                        $queryVector,
                        json_decode($article->getEmbedding(), true)
                    );
                    $results[] = [
                        'id' => $article->getId(),
                        'title' => $article->getTitle(),
                        'similarity' => $score,
                    ];
                }
            }

            usort($results, fn($a, $b) => $b['similarity'] <=> $a['similarity']);
            return $this->json(array_slice($results, 0, 5)); // top 5 results
        }

        private function getEmbedding(string $text): array
        {
            $payload = [
                'model' => 'text-embedding-3-small',
                'input' => $text,
            ];

            $ch = curl_init($this->endpoint);
            curl_setopt_array($ch, [
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_HTTPHEADER => [
                    "Content-Type: application/json",
                    "Authorization: Bearer {$this->apiKey}"
                ],
                CURLOPT_POST => true,
                CURLOPT_POSTFIELDS => json_encode($payload)
            ]);

            $response = curl_exec($ch);
            curl_close($ch);

            $data = json_decode($response, true);
            return $data['data'][0]['embedding'] ?? [];
        }

        private function cosineSimilarity(array $a, array $b): float
        {
            $dot = 0; $magA = 0; $magB = 0;
            for ($i = 0; $i < count($a); $i++) {
                $dot += $a[$i] * $b[$i];
                $magA += $a[$i] ** 2;
                $magB += $b[$i] ** 2;
            }
            return $dot / (sqrt($magA) * sqrt($magB));
        }
    }

Now, even if the articles don't contain the exact keywords, your /search?q=php framework tutorial endpoint will return those that are most semantically similar to the query.

Step 4: Try It Out

Run the below command.

php bin/console app:generate-embeddings

This generates embeddings for all articles.

Now visit the following URL.

http://your-symfony-app.local/search?q=learn symfony mvc

The top five most pertinent articles will be listed in a JSON response, arranged by meaning rather than keyword.

Real-World Applications

A more intelligent search within a CMS or knowledge base
AI-supported matching of FAQs
Semantic suggestions ("you might also like..."
Clustering of topics or duplicates in admin panels

Tips for Security and Performance

Reuse and cache embeddings (avoid making repeated API calls for the same content).
Keep your API key in.env.local (OPENAI_API_KEY=your_key).
For better performance, think about using a vector database such as Pinecone, Weaviate, or Qdrant if you have thousands of records.

AI Text Summarization for Drupal 11 Using PHP and OpenAI API

noreply@blogger.com (PHP CMS Frameworks) — Fri, 07 Nov 2025 12:58:00 +0000

Drupal's body field has a built-in summary subfield that almost nobody fills in properly. On high-volume editorial sites I've worked on, it's either blank, copy-pasted from the first paragraph, or written by someone who clearly didn't read the article. It shows up in teasers, RSS feeds, and meta descriptions, so bad summaries actually hurt.

The fix is straightforward. Hook into hook_entity_presave, grab the body content, send it to OpenAI, write the result back into body->summary before the node hits the database. Editors never have to touch it, and the summaries are actually coherent.

This is a single-file custom module. No services, no config forms, no dependencies beyond cURL. If you want to wire it up properly with Drupal's config system later you can, but this gets you running in under 20 minutes.

Prerequisites

Before starting, make sure you have:

Drupal 11
PHP 8.1 or higher
Composer
cURL enabled
An OpenAI API key

Step 1: Create a Custom Module

Create a new module called ai_summary.

/modules/custom/ai_summary/

Inside that folder, create two files:

ai_summary.info.yml
ai_summary.module

ai_summary.info.yml

Add the below code in the info.yml file.

   name: AI Summary
   type: module
   description: Automatically generate summaries for Drupal nodes using OpenAI API.
   core_version_requirement: ^11
   package: Custom
   version: 1.0.0

ai_summary.module

This is where the logic lives.

To run our code just before a node is saved we will use hook_entity_presave of Drupal.

use Drupal\node\Entity\Node;
use Drupal\Core\Entity\EntityInterface;

/**
* Implements hook_entity_presave().
*/
function ai_summary_entity_presave(EntityInterface $entity) {
    if ($entity->getEntityTypeId() !== 'node') {
        return;
    }

    // Only summarize articles (you can change this as needed)
    if ($entity->bundle() !== 'article') {
        return;
    }

    $body = $entity->get('body')->value ?? '';
    if (empty($body)) {
        return;
    }

    // Generate AI summary
    $summary = ai_summary_generate_summary($body);

    if ($summary) {
        // Save it in the summary field
        $entity->get('body')->summary = $summary;
    }
}

/**
* Generate summary using OpenAI API.
*/
function ai_summary_generate_summary($text) {
    $api_key = 'YOUR_OPENAI_API_KEY';
    $endpoint = 'https://api.openai.com/v1/chat/completions';

    $payload = [
        "model" => "gpt-4o-mini",
        "messages" => [
        ["role" => "system", "content" => "Summarize the following text in 2-3 sentences. Keep it concise and human-readable."],
        ["role" => "user", "content" => $text]
        ],
        "temperature" => 0.7
    ];

    $ch = curl_init($endpoint);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "Authorization: Bearer {$api_key}"
        ],
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => json_encode($payload),
        CURLOPT_TIMEOUT => 15
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    $data = json_decode($response, true);
    return trim($data['choices'][0]['message']['content'] ?? '');
}

This functionality performs three primary functions:

Identifies article saving in Drupal.
Sends the content to OpenAI to be summarized.
The summary is stored in the body summary field of the article.

Step 2: Enable the Module

Place the new module folder directly in /modules/custom/.
In Drupal Admin panel, go to: Extend → Install new module (or Enable module).
Check AI Summary and turn it on.

Step 3: Test the AI Summary

Select Content -> Add content -> Article.
Enter the long paragraph in the body field.
Save the article.
On reloading the page, open it one more time — the summary field will be already filled automatically.

Example:

Input Body:

Artificial Intelligence has been changing how developers build and deploy applications...

Generated Summary:

AI is reshaping software development by automating repetitive tasks and improving decision-making through data-driven insights.

Step 4: Extend It Further

The following are some of the ideas that can be used to improve the module:

Add settings: Add a form to enable the user to add the API key and the select the type of model.
Queue processing: Queue processing Use the drugndrup queue API to process the existing content in batches.
Custom field storage: Store summaries in object now: field_ai_summary.
Views integration: Show or hide articles in terms of length of summary or its presence.

Security & Performance Tips

Never hardcode your API key but keep it in the configuration or in the.env file of Drupal.
Shorten long text in order to send (OpenAI token limit = cost).
Gracefully manage API timeouts.
Watchdoging errors to log API.

Building a Sentiment Analysis Plugin in Joomla Using PHP and OpenAI API

noreply@blogger.com (PHP CMS Frameworks) — Mon, 03 Nov 2025 14:48:00 +0000

Joomla's content plugin system is underused. Most developers reach for components when a simple content plugin hooked into onContentBeforeSave would do the job in a fraction of the code.

This tutorial is a good example of that. The idea is simple: every time an article is saved, we send the text to OpenAI and get back one word, positive, negative, or neutral.

That result gets appended to the meta keywords field and flashed as an admin message. Nothing fancy, but on a community site or news portal where editors are processing dozens of submissions a day, having that sentiment label right in the save workflow saves real time.

Two files, no Composer, no service container. Just a manifest XML and a single PHP class extending CMSPlugin.

What You’ll Need

Before we start, make sure you have:

Joomla 5.x installed
PHP 8.1 or newer
cURL enabled on your server
An OpenAI API key

Once that’s ready, let’s code.

Step 1: Creation of the Plugin

In your Joomala system, make a new folder within the system under the name of the plugin:

/plugins/content/aisentiment/

Thereupon in that folder generate two files:

aisentiment.php
aisentiment.xml

aisentiment.xml

This is the manifest file that the Joomla plugin identifies the identity of this particular plugin and the files that should be loaded into it.

<?xml version="1.0" encoding="utf-8"?><extension type="plugin" version="5.0" group="content" method="upgrade">
    <name>plg_content_aisentiment</name>
    <author>PHP CMS Framework</author>
    <version>1.0.0</version>
    <description>Analyze sentiment of comments or articles using OpenAI API.</description>
    <files>
        <filename plugin="aisentiment">aisentiment.php</filename>
    </files>
</extension>

Step 2: Add the PHP Logic

Now let’s write the plugin code.

aisentiment.php

<?php

defined('_JEXEC') or die;

use Joomla\CMS\Plugin\CMSPlugin;

use Joomla\CMS\Factory;

class PlgContentAisentiment extends CMSPlugin

{

private $apiKey = 'YOUR_OPENAI_API_KEY';

private $endpoint = 'https://api.openai.com/v1/chat/completions';

public function onContentBeforeSave($context, $table, $isNew, $data)

{

// Only process if content exists

if (empty($data['introtext']) && empty($data['fulltext'])) {

return true;

}

$text = strip_tags($data['introtext'] ?? $data['fulltext']);

$sentiment = $this->getSentiment($text);

if ($sentiment) {

$data['metakey'] .= ' Sentiment:' . ucfirst($sentiment);

Factory::getApplication()->enqueueMessage("AI Sentiment: {$sentiment}", 'message');

}

return true;

}

private function getSentiment($text)

{

$payload = [

"model" => "gpt-4o-mini",

"messages" => [

["role" => "system", "content" => "You are a sentiment analysis model. Return only one word: positive, negative, or neutral."],

["role" => "user", "content" => $text]

]

];

$ch = curl_init($this->endpoint);

curl_setopt_array($ch, [

CURLOPT_RETURNTRANSFER => true,

CURLOPT_HTTPHEADER => [

"Content-Type: application/json",

"Authorization: Bearer {$this->apiKey}"

CURLOPT_POST => true,

CURLOPT_POSTFIELDS => json_encode($payload),

CURLOPT_TIMEOUT => 15

]);

$response = curl_exec($ch);

curl_close($ch);

$data = json_decode($response, true);

return strtolower(trim($data['choices'][0]['message']['content'] ?? 'neutral'));

}

This extension will be installed on Joomla and will work together with the content workflow (onContentBeforeSave) and send the content of the article to the OpenAI API. This model examines the tone and produces one of three values, including positive, negative, and neutral.

The output is presented in the administration of Joomla as an output when the article is saved.

Step 3:Install and activate the Plugin.

Zip the folder (aisentiment) of the compressor: aisentiment.zip

Within Joomla administration log, go to: System → Extensions → Install

Upload the zip file.

Once installed, visit System -> Plugins where you will find the AI Sentiment one and turn it on.

Step 4: Test It

Open an existing article, or create one.

Enter some text — for example:

This product is out of my expectations and it works excellently!

Click Save.

Joomla will show such a message as: AI Sentiment: positive

Or you can save the response in a custom field and present it on the front end.

Bonus Tips:

Store your API key securely in Joomla’s configuration or an environment variable (not hard-coded).
Add caching if you’re analyzing large volumes of content.
Trim long text before sending to OpenAI to save API tokens.
Handle failed API calls gracefully with proper fallbacks.

Real-World Use Cases:

Highlight positive user reviews automatically.
Flag negative feedback for moderation.
Generate sentiment dashboards for community comments.

In the next part of our AI + PHP CMS series, we’ll move to Drupal 11, where we’ll build an AI Text Summarization module using PHP and OpenAI API.

Unleashing the Power of Drupal 10: Advantages and Features

noreply@blogger.com (PHP CMS Frameworks) — Sat, 29 Jul 2023 15:51:00 +0000

As technology continues to evolve, so does the web development landscape, and Drupal, the renowned open-source content management system (CMS), stays at the forefront of innovation. With the release of Drupal 10, developers and site owners have access to a host of exciting advantages and features that take web development to new heights. In this blog post, we'll explore the key advantages of Drupal 10 and highlight the cutting-edge features that make it the preferred choice for building powerful and scalable websites.

1. Enhanced Accessibility

Accessibility is no longer an option; it's a necessity. Drupal 10 understands this, and its commitment to making the web inclusive for all is evident through its enhanced accessibility features. The platform comes with improved semantic HTML, ARIA enhancements, and focus management, ensuring that websites built on Drupal 10 are accessible to people with disabilities. By prioritizing accessibility, you can reach a wider audience and demonstrate your commitment to providing a positive user experience for everyone.

2. API-First Approach

Drupal 10 embraces the API-first approach, a trend that's gaining momentum in the web development community. This feature allows developers to separate the frontend and backend of their websites, giving them the freedom to choose the best technology stack for each aspect. With Drupal's robust APIs, you can build headless or decoupled applications, providing seamless user experiences across various devices and platforms. This versatility is ideal for creating dynamic applications, progressive web apps (PWAs), and mobile experiences.

3. Streamlined Content Editing with Claro

Drupal 10 introduces the Claro administration theme, a significant improvement to the user interface for content editors and site administrators. Claro is designed to be visually appealing, intuitive, and user-friendly, making content management a breeze. With a modern and clean interface, content editors can focus on creating engaging content without getting bogged down by complicated backend systems. Claro streamlines the content editing process, increasing efficiency and productivity for website maintenance tasks.

4. Effortless Migration from Drupal 9

For organizations currently using Drupal 9, upgrading to Drupal 10 is a smooth and hassle-free process. The Drupal community has worked diligently to ensure backward compatibility between the versions, making it easier to migrate your existing projects seamlessly. This allows you to take advantage of Drupal 10's new features while leveraging your existing codebase and modules.

5. Improved Performance and Scalability

Performance is critical for any website, and Drupal 10 comes packed with performance improvements that enhance the overall speed and efficiency of your site. The platform has undergone codebase optimizations, caching enhancements, and database query optimizations, resulting in faster page load times and improved responsiveness. Whether you run a small blog or a large enterprise platform, Drupal 10 can handle the scale, ensuring a smooth user experience for all visitors.

6. Robust Security Features

Security is a paramount concern for any CMS, and Drupal has a long-standing reputation for its robust security architecture. Drupal 10 continues this tradition, providing a secure foundation for your web projects. Regular security updates, improved password hashing algorithms, and adherence to industry best practices make Drupal 10 a secure choice for building websites and applications.

Conclusion

Drupal 10 is a game-changer in the world of web development, offering a wide array of advantages and features that cater to the needs of modern websites and applications. With enhanced accessibility, an API-first approach, streamlined content editing, easy migration, improved performance, and robust security features, Drupal 10 empowers developers and site owners to build cutting-edge digital experiences.

Whether you're starting a new project or upgrading an existing one, Drupal 10 provides the flexibility, scalability, and security required to create exceptional websites that engage and delight users. Embrace the power of Drupal 10 and elevate your web development endeavors to new heights. Happy building!

Introducing Drupal 10: The Next Evolution in Web Development

noreply@blogger.com (PHP CMS Frameworks) — Thu, 27 Jul 2023 17:41:00 +0000

Introduction

Welcome to the future of web development! Drupal, the powerful open-source content management system (CMS), has reached a new milestone with the release of Drupal 10. As we bid adieu to Drupal 9 and embrace the latest iteration, developers and site builders can look forward to a plethora of exciting features, enhancements, and optimizations that make building robust, secure, and scalable websites easier than ever. In this blog post, we'll delve into the highlights of Drupal 10 and explore the reasons why it's the ultimate choice for your web projects.

1. Accessibility First

Accessibility has always been a priority for Drupal, and with Drupal 10, this commitment is taken to new heights. The core development team has worked tirelessly to ensure that Drupal 10 adheres to the latest web accessibility standards, making it possible for everyone to access and interact with websites built on the platform, regardless of their physical abilities. Improved semantic HTML, ARIA enhancements, and focus management are some of the accessibility-focused improvements that will empower developers to create inclusive digital experiences effortlessly.

2. API-First Approach

Drupal has been at the forefront of embracing API-first design principles, and this trend continues with Drupal 10. The new version comes with enhanced support for headless and decoupled architectures, allowing developers to use Drupal as a content repository while building frontend experiences using the technologies of their choice, such as React, Angular, or Vue.js. This flexibility opens up a world of possibilities for creating seamless omnichannel experiences and empowers organizations to deliver content to various devices and platforms.

3. Easy Migration from Drupal 9

If you're already using Drupal 9 for your website, transitioning to Drupal 10 is a breeze. The development team has streamlined the upgrade process, making it easier and faster to move your existing projects to the latest version. Additionally, Drupal 10's backward compatibility ensures that modules and themes written for Drupal 9 will continue to function smoothly, allowing you to leverage your existing codebase and investments.

4. Enhanced Performance and Scalability

Drupal 10 brings significant performance improvements, optimizing the CMS to handle larger and more complex websites with ease. Whether you're running a small business site or a high-traffic enterprise platform, Drupal 10's enhancements in caching, database queries, and overall codebase optimization will ensure your website performs at its best, providing a seamless user experience even during peak traffic.

5. Streamlined Content Editing

Content editors and site administrators will love the enhanced content editing experience in Drupal 10. With the introduction of the Claro administration theme in Drupal 8 and further improvements in Drupal 9, Drupal 10 takes the user interface to the next level. The admin interface is now more intuitive, user-friendly, and visually appealing, reducing the learning curve and making content management a joyous task.

6. Robust Security Features

Security remains a top priority for Drupal, and Drupal 10 continues to build upon the platform's already robust security architecture. With regular security updates and features like improved password hashing algorithms, security-conscious organizations can trust Drupal 10 to safeguard their digital assets effectively.

Conclusion

Drupal 10 marks a significant milestone in the evolution of the CMS, presenting an impressive array of features that cater to the needs of modern web development. From enhanced accessibility to API-first capabilities, easy migration, improved performance, streamlined content editing, and robust security features, Drupal 10 promises to revolutionize the way websites are built and managed.

So, whether you're a developer, site builder, or organization looking to create dynamic and innovative digital experiences, Drupal 10 provides the ideal platform to bring your vision to life. Embrace the power of Drupal 10 and join the ever-growing community of web professionals shaping the future of the internet. Happy building!

Steps to create a Contact Form in Symfony With SwiftMailer

noreply@blogger.com (PHP CMS Frameworks) — Mon, 14 Feb 2022 19:29:00 +0000

In this article, we are going to discuss about How we can create a contact form in Symfony with SwiftMailer. Symfony provides an architecture, components and tools for developers to build complex web applications faster. Choosing symfony allows you to release your applications earlier, host and scale them without problem, and maintain them over time with no surprise.

Swift Mailer is a component based library for sending e-mails from PHP applications. Swift Mailer supports PHP 7.0 to PHP 8.1 included (proc_* functions must be available). Swift Mailer does not work when used with function overloading as implemented by mbstring when mbstring.func_overload is set to 2.

At the end of this article, we will be created a contact form in Symfony using Form Builder and connected with SwiftMailer bundle. So that, the visitor could receive acknowledgement that the messages has been successfully sent.

Step 1: Create Contact Entity with Doctrine

First of all we need to create and configure the database. Database related information and credentials are available in Application Access details panel. Add these to the app/config/parameters.yml

parameters:

   database_host: localhost
   database_port: <PORT>
   database_name: <DB_NAME>
   database_user: <DB_user_name>
   database_password: <DB_password>

Next, we need to create a contact entity with Doctrine. To use Doctrine, open SSH terminal and go to your Symfony project:

cd application/{your_app_folder}/public_html

Now run the following command to start the entity generator:

php bin/console doctrine:generate:entity

For the contact form I need four fields: name, email, subject, message. You can add more fields as per your requirements. The entity name will be Contact and the shortcut name will be AppBundle:Contact. Annotation will be Yaml, so just press the Enter key on this.

Now go to src/AppBundle/Entity. You will see a Contact.php file in which Doctrine has created a new method for every field. I will use these methods to set values in the Controller:

<?php
namespace AppBundle\Entity;
use Doctrine\ORM\Mapping as ORM
/**
* Contact
*
* @ORM\Table(name="contact")
* @ORM\Entity(repositoryClass="AppBundle\Repository\ContactRepository")
*/
class Contact
{
/**
* @var int
*
* @ORM\Column(name="id", type="integer")
* @ORM\Id
* @ORM\GeneratedValue(strategy="AUTO")
*/
private $id;
/**
* @var string
*
* @ORM\Column(name="name", type="string", length=255)
*/
private $name;
/**
* @var string
*
* @ORM\Column(name="email", type="string", length=255)
*/
private $email;
/**
* @var string
*
* @ORM\Column(name="subject", type="string", length=255)
*/
private $subject;
/**
* @var string
*
* @ORM\Column(name="message", type="string", length=255)
*/
private $message;
/**
* Get id
*
* @return int
*/
public function getId()
{
return $this->id;
}
/**
* Set name
*
* @param string $name
*
* @return Contact
*/
public function setName($name)
{
$this->name = $name;
return $this;
}
/**
* Get name
*
* @return string
*/
public function getName()
{
return $this->name;
}
/**
* Set email
*
* @param string $email
*
* @return Contact
*/
public function setEmail($email)
{
$this->email = $email;
return $this;
}
/**
* Get email
*
* @return string
*/
public function getEmail()
{
return $this->email;
}
/**
* Set subject
*
* @param string $subject
*
* @return Contact
*/
public function setSubject($subject)
{
$this->subject = $subject;
return $this;
}
/**
* Get subject
*
* @return string
*/
public function getSubject()
{
return $this->subject;
}
/**
* Set message
*
* @param string $message
*
* @return Contact
*/
public function setMessage($message)
{
$this->message = $message;
return $this;
}
/**
* Get message
*
* @return string
*/
public function getMessage()
{
return $this->message;
}
}

Next, we will work on the Controller and the form View.

Step 2: Create the Form in DefaultController.php

The next step is to create a form in the controller. You can also create a form in the Twig view. However, in this article, I will initialize the form fields using the Symfony’s form builder, and then show the form Widget in the View.

Open DefaultController.php and add the following namesapaces and the entity (created earlier):

namespace AppBundle\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Form\Extension\Core\Type\DateTimeType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\HttpFoundation\Session\Flash\FlashBag;
use AppBundle\Entity\Contact;

Now in the createAction() method, create an entity object and pass it to the form builder. The form contains the input fields (as discussed earlier).

class DefaultController extends Controller
{
/**
* @Route("/form", name="homepage")
*/
public function createAction(Request $request)
{
$contact = new Contact;
# Add form fields
$form = $this->createFormBuilder($contact)
->add('name', TextType::class, array('label'=> 'name', 'attr' => array('class' => 'form-control', 'style' => 'margin-bottom:15px')))
->add('email', TextType::class, array('label'=> 'email','attr' => array('class' => 'form-control', 'style' => 'margin-bottom:15px')))
->add('subject', TextType::class, array('label'=> 'subject','attr' => array('class' => 'form-control', 'style' => 'margin-bottom:15px')))
->add('message', TextareaType::class, array('label'=> 'message','attr' => array('class' => 'form-control')))
->add('Save', SubmitType::class, array('label'=> 'submit', 'attr' => array('class' => 'btn btn-primary', 'style' => 'margin-top:15px')))
->getForm();
# Handle form response
$form->handleRequest($request);

Step 3: Create View for the Contact Form

To view this form on the Twig template, create a file form.html.twig in app/Resources/views/default and add the form widget to it.

{% block body %}
<div class="container">
<div class="row">
<div class="col-sm-4">
<h2 class=page-header>Contact Form in Symfony</h2>
{{form_start(form)}}
{{form_widget(form)}}
{{form_end(form)}}
</div>
</div>
</div>
{% endblock %}

I have added bootstrap classes to the code. I will now add the bootstrap CDN to base template to make the classes work.

Open the base.html.twig from app/Resources/views and add the CDN links to it.

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>{% block title %}Welcome!{% endblock %}</title>
{% block stylesheets %}{% endblock %}
<link rel="icon" type="image/x-icon" href="{{ asset('favicon.ico') }}" />
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="alert alert-success">
{% set flashbag_notices = app.session.flashbag.get('notice') %}
{% if flashbag_notices is not empty %}
<div class="flash-notice">
{% for notice in flashbag_notices %}
{{notice}}
{% endfor %}
</div>
{% endif %}
{% block body %}{% endblock %}
</div>
{% block javascripts %}{% endblock %}
</body>
</html>

Now I need to extend form.html.twig with base.html.twig by simply adding the following line at the top.

{% extends 'base.html.twig' %}

At this point, if you hit the /form Route, you will get the following Form:

Step 4: Save Values in the Database

Next, we will save the values in database. We have already created the form in the DefaultController class. First, we will save the values in variables and then pass these variables to the related methods in the entity. Finally, we will save the variables through the persist() method.

# check if form is submitted
if($form->isSubmitted() && $form->isValid()){
$name = $form['name']->getData();
$email = $form['email']->getData();
$subject = $form['subject']->getData();
$message = $form['message']->getData();
# set form data
$contact->setName($name);
$contact->setEmail($email);
$contact->setSubject($subject);
$contact->setMessage($message);
# finally add data in database
$sn = $this->getDoctrine()->getManager();
$sn -> persist($contact);
$sn -> flush();

Now, when the form is submitted, the values will be available in the database.

Step 5: Send Acknowledgement to the User

It is important to tell the user that their message has been successfully delivered to the website. Many websites send an email that provides all user-submitted data in a proper format.

For this purpose, I will use SwiftMailer, a bundle that comes preinstalled in Symfony 3. To use it, you just need to configure it. To do the necessary changes, open app/config/parameters.yml under parameters

mailer_transport: gmail
mailer_host: smtp.gmail.com
mailer_user: <SMTP_USERNAME>
mailer_password: <SMTP_PASSWORD>
secret: Itmaybeanything
encryption: tls

Now in the config.yml, add the following code to get the values:

# Swiftmailer Configuration
swiftmailer:
transport: "%mailer_transport%"
host: "%mailer_host%"
username: "%mailer_user%"
password: "%mailer_password%"
spool: { type: memory }

The configuration process is over. Now, open DefaultController.php and add the code for SwiftMailer. I will use the same data variables in this code:

$message = \Swift_Message::newInstance()
->setSubject($subject)
->setFrom('shahroznawaz156@gmail.com')
->setTo($email)
->setBody($this->renderView('default/sendemail.html.twig',array('name' => $name)),'text/html');
$this->get('mailer')->send($message);

Notice that you can also send email templates. In this code snippet, I sent the email template I created (sendemail.html.twig) in the views/default. This template has a simple test message.

{# app/Resources/views/Emails/sendemail.html.twig #}
<h3>You did it</h3>
Hi {{ name }}! Your Message is successfully Submitted.
We will get back to you soon!
Thanks!

Now, when you submit the form, you will get an acknowledgment email in your inbox.

If you have a query or would like to contribute to the discussion, do leave a comment.

How to implement Functional Test in Symfony 4 with Kahlan 4

noreply@blogger.com (PHP CMS Frameworks) — Sun, 30 Jan 2022 20:30:00 +0000

In this tutorial, we are going to discuss about how to implement the functional testing in Symfony 4 with Kahlan 4. In IT world, whenever we are creating an application/website, we need to test the application/website thouroghly. To perform the functional testing we have a bundle in Symfony 4.

The simplest way is define Symfony 4 skeleton bootstrap in kahlan config, and use its property at specs, for example, we configure config at kahlan-config.php as follows:

suite()->root();
    $root->beforeAll(function () {
        $this->request = Request::createFromGlobals();
        $this->kernel  = new Kernel('test', false);
    });
    return $next();
});

Above settings are minimal, if you need more setup, you can define there. If you didn’t require kahlan/kahlan:^4.0, you can require via composer:

$ composer require --dev kahlan/kahlan:^4.0

Give a try

Let’s try testing a famous /lucky/number from LuckyController. We have the following controller:

render('lucky/number.html.twig', [
            'number' => $number,
        ]);
    }
}

And our twig file is:

{# templates/lucky/number.html.twig #}
<h1>Your lucky number is {{ number }}</h1>

We can place test under spec directory at root directory, for its test, we can create a spec/Controller directory:

kahlan.config.php
spec
Controller

Now, we can create the test as follows with make request to the ‘/lucky/number’ page and get its response. We can use toMatchEcho matcher provided with regex to get match random number of mt_rand(0, 100) that printed inside a response html content:

request->create('/lucky/number', 'GET');
            $response = $this->kernel->handle($request);
 
            expect(function () use ($response) {
                $response->send();
            })->toMatchEcho(
                "#Your lucky number is ([0-9]|[1-8][0-9]|9[0-9]|100)#"
            );
 
        });
 
    });
 
});

Time to run it with command:

$ vendor/bin/kahlan

By running the above commmand, you will get an Output.

Display personalised content in Drupal - Smart Content Paragraphs

noreply@blogger.com (PHP CMS Frameworks) — Wed, 26 Jan 2022 19:20:00 +0000

In this tutorial we are going to discuss about, how to display the personalised content (Paragraphs) for each person (both anonymous and authenticated users) in Drupal.

Smart content module allows personalised blocks only. If we need to display the personalised Paragraphs, then we need to go for Smart Content Paragraphs module which will supports Paragraphs as well.

Dependent Modules

Paragraphs (https://www.drupal.org/project/paragraphs)
Smart Content (https://www.drupal.org/project/smart_content)
Smart Content Segments (https://www.drupal.org/project/smart_content_segments)

Smart Content Paragraphs uses conditions, within Segments, to determine whether or not to display the reaction(s) defined within a Decision Block. A Condition is a single case that can be tested and determined to be either true or false, multiple conditions can be included in a Segment and a Segment Set is one or more Segments grouped together.

Click Here to Donwload the Module

Click Here to view the releases

Create custom theme in Drupal 8

noreply@blogger.com (PHP CMS Frameworks) — Sun, 09 Sep 2018 17:53:00 +0000

In this tutorial we are going to discuss about, How to create custom theme (template) in Drupal 8 PHP CMS. By creating custom theme, we can customize the look and feel of the website as per our wish instead of using the pre-defined template or third party templates.

To create a new template, we have to follow the following steps.

Create YAML (.yml) file
Edit YAML (.yml) file
Remove stylesheets
Clear the cache
Optimize the Website
Add CSS
Add Javascript

Step 1: Create YAML (.yml) file

In Drupal 8, YAML file (.yml) is used in the place of .INFO files (used in Drupal 7) to tell the website that the theme exists. Similarly, the directories that contain the theme and the files with theme details have also been changed.

Create a folder with the theme name which we are going to create like (first_theme) inside the <root>/theme folder.
Create a new file inside the folder with the name first_theme.info.yml.

Step 2: Edit YAML file

Open the YAML file in your preferred text editor and enter the following details:

name: first_theme

description: Enter some description about your template

type: theme

core: 8.x

Type is theme and core is the version of Drupal you are creating the theme for (In this is case it is Drupal 8, so 8.x).

Now go to your Drupal website and check if the new theme appears in the Drupal appearance section. If all the steps have been correctly followed, the theme will appear in the uninstalled section of your website’s appearance tab.

Click install and set as default to set this theme as default.

Step 3: Remove Stylesheets (Optional)

After you have set the new theme as default, and then navigate to the website’s homepage, you will notice that nothing has changed. This is because Drupal includes several stylesheets that loads by default. In many cases, the best strategy is to disable some of these stylesheets.

To find out these stylesheets, you will need to inspect the source code by right-clicking and selecting View Source from the context menu and determine which CSS files you wish to remove, the rest of the process is pretty straightforward.

Go back to the first_theme.info.yml file and edit it. To remove the stylesheets you want, add this text:

stylesheets-remove

-“stylesheet to be removed”

Step 4: Clear the Cache

Now login to your Drupal website’s admin panel. Next, go to Configuration >> Performance and click Clear all caches.

Step 5: Optimize the Website

Next, go back to the Performance page and uncheck Aggregate CSS files and Aggregate JavaScript files in the Bandwidth Optimization section. This will help in speeding up the performance of the website.

Step 6: Add CSS

It is time to add reference to the CSS file that will be used for/by the theme. To do this, go to the theme’s folder and create a new file named first_theme.libraries.yml and update the file with css files which we are going to use in the theme.

global-css:

css:

theme:

css/style.css:{}

Now, add the library in the first_theme.info.yml file as well. To do this, add the below code in the file.

libraries:

-first_theme/global-css

Step 7: Add JavaScript Reference

To add reference to the JavaScript reference to the theme, add the below code snippet to the first_theme.libraries.yml file.

global-js:

js:

js/site.js:{}

dependencies:

-core/jquery

Now, add the the JavaScript library in the first_theme.info.yml file.

-first_theme/global-js

Finally the first_theme.info.yml will looks like below,

name: first_theme

description: Enter some description about your template

type: theme

core: 8.x

libraries:

-first_theme/global-css

-first_theme/global-js

XML Views in CakePHP

noreply@blogger.com (PHP CMS Frameworks) — Wed, 14 Oct 2015 16:26:00 +0000

In this article, we are going to discuss about how to return XML response to views in CakePHP. CakePHP is an open source web application framework. It follows the Model-View-Controller (MVC) approach and is written in PHP, modeled after the concepts of Ruby on Rails, and distributed under the MIT License.CakePHP uses well-known software engineering concepts and software design patterns, such as Convention over configuration, Model-View-Controller, Active Record, Association Data Mapping, and Front Controller.

Step 1:

Open the file "app\Config\routes.php" and added the following line:

/**
* Parse XML Routes
*/
Router::parseExtensions('xml');

This enables your Controller actions to start accepting the .xml postfix e.g. http://cakephp_app/controller/action.xml

Step 2:

Enable the RequestHandler component in your Controller like this:

public $components = array('RequestHandler');

Step 3:

Once that's done, you have a few more methods at your disposal to start dealing with XML requests. First create a beforeFilter method in your Controller and add the following:

public function beforeFilter() {
parent::beforeFilter();

// Set XML
if ($this->RequestHandler->isXml()) {
$this->RequestHandler->setContent('xml');
}
}

Step 4:

Once that's done, create the action that you want to use and be sure to add in the respondAs & renderAs methods as the official documentation is a bit flakey with their use:

public function related() {
// Only allow XML requests
if (!$this->RequestHandler->isXml()) {
throw new MethodNotAllowedException();
}

// Set response as XML
$this->RequestHandler->respondAs('xml');
$this->RequestHandler->renderAs($this, 'xml');
}

Step 5:

Using those 2 methods as I was then able to create an xml folder in the corresponding View folder and inside that create my view file e.g. app\View\Uploads\xml\related.ctp

<?xml version="1.0"?>
<people>
<person>
<name>James</name>
</person>
</people>

Now if you visited the page in your browser you should see your XML output as per your View e.g. http://cakephp_app/uploads/related.xml

Wrapping Up

Further to this if you wanted to pass in some parameters to make the Controller action dynamic you can do by using the following e.g. http://cakephp_app/uploads/related/videos/1.xml

The "videos" parameter and the "1" ID will be available in the Controller like this:

// Get passed params
$uploadType = $this->request->params['pass'][0];
$uploadId = $this->request->params['pass'][1];

Automatically Create a Bit.ly URL for WordPress Posts

noreply@blogger.com (PHP CMS Frameworks) — Wed, 23 Sep 2015 16:26:00 +0000

In this article, we are going to discuss about How to create Bit.ly URL for WordPress posts automatically. Bit.ly is currently the most popular URL shorting service out there and for a good reason too. With bit.ly you can track your shortened URLs and much more. In this article I'm going to show you how to use bit.ly's api create bit.ly urls automatically for WordPress posts.

In order to make use of Bit.ly's API, you'll need to:

Now that you have a login and API key, open your WordPress theme's functions.php (just create one if you don't have one) and paste the following code at the top of the document:

//create bit.ly url
function bitly()
{
//login information
$url = get_permalink(); //generates wordpress' permalink
$login = 'imjp'; //your bit.ly login
$apikey = 'R_11882237eac772b5d6126e895a06c43f'; //bit.ly apikey
$format = 'json'; //choose between json or xml
$version = '2.0.1';

//create the URL
$bitly = 'http://api.bit.ly/shorten?version='.$version.'&longUrl='.urlencode($url).'&login='.$login.'&apiKey='.$apikey.'&format='.$format;

//get the url
//could also use cURL here
$response = file_get_contents($bitly);

//parse depending on desired format
if(strtolower($format) == 'json')
{
$json = @json_decode($response,true);
echo $json['results'][$url]['shortUrl'];
}
else //xml
{
$xml = simplexml_load_string($response);
echo 'http://bit.ly/'.$xml->results->nodeKeyVal->hash;
}
}

The code above is pretty much self explanatory.

Don't forget to change the login and apikey strings to match yours.

I hope you guys found this article useful.

TZ Portfolio - A joomla portpolio component / Module / Plugin download

noreply@blogger.com (PHP CMS Frameworks) — Wed, 02 Sep 2015 16:28:00 +0000

TZ Portfolio works on database of comcontent, sothat you do not have to worry about importing or exporting data from your system (which already works with comcontent). TZ Portfolio inherits all current functions of com_content, in addition, we develop two new data interfaces: Portfolio and Timeline view. TZ Portfolio is strongly supported by Group Extra field system, you can create multi-portfolio system in your website. In addition, it supply 3 functions , these are video display, gallery or representative photo displayed for each article.

We also upgrade tag and authority information management function, along with photo smart resize and crop. With TZ Portfolio you can own a smart blog, a flexible portfolio, and more than a complete content management system.

Extension Name: TZ Portfolio

Price: Free

More info and reviews: TZ Portfolio on JED

For Demo - Click Here

To download the component - Click Here

For Documentation - Click Here

For Support - Click Here