Forem: PHP CMS Framework

Magento 2 - tips and tricks every Developer should know

PHP CMS Framework — Tue, 07 Apr 2026 04:25:57 +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.

For more details - https://www.phpcmsframework.com/2026/04/magento-2-tips-tricks-developers.html

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

PHP CMS Framework — Sat, 04 Apr 2026 17:15:25 +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.

For more details - https://www.phpcmsframework.com/2026/04/laravel-prism-php-ai-models.html

Build a RAG Pipeline Inside Joomla for Intelligent Site Search

PHP CMS Framework — Tue, 31 Mar 2026 18:12:08 +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.

For more details : https://www.phpcmsframework.com/2026/03/joomla-rag-pipeline-intelligent-site-search.html

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

PHP CMS Framework — Sat, 28 Mar 2026 13:52:47 +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.

For more info : https://www.phpcmsframework.com/2026/03/drupal-langchain-ai-pipeline-enterprise-cms.html

Build a WhatsApp AI Assistant Using Laravel, Twilio and OpenAI

PHP CMS Framework — Wed, 25 Mar 2026 15:37:52 +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.

For more Details -> https://www.phpcmsframework.com/2026/03/whatsapp-ai-assistant-laravel-twilio-openai.html

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

PHP CMS Framework — Sat, 21 Mar 2026 20:41:19 +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

PHP CMS Framework — Thu, 19 Mar 2026 06:45:29 +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.

Original post available in - https://www.phpcmsframework.com/2026/03/building-rag-system-in-laravel-from-scratch.html

AI SEO Content Quality Analyzer for WordPress Using PHP and OpenAI

PHP CMS Framework — Tue, 27 Jan 2026 14:00:54 +0000

Plugins for SEO tell you what needs to be fixed, but not why.

They look at readability scores, keyword density, and meta length, but they totally ignore search intent, semantic depth, and content quality.

In this tutorial, we'll use PHP and OpenAI to create an AI-powered SEO Content Quality Analyzer for WordPress.

AI will assess content in the same manner as a search engine rather than according to strict guidelines.

Real-time post analysis and actionable SEO feedback are provided by this tool, which operates within WordPress Admin.

For more details: https://www.phpcmsframework.com/2026/01/ai-seo-content-quality-analyzer-for-wordpress-with-php-openai.html

AI Duplicate Content Detector for Symfony Using PHP and OpenAI Embeddings

PHP CMS Framework — Mon, 29 Dec 2025 14:46:28 +0000

In many Symfony-based CMS and blog applications, duplicate content is a silent issue. Similar articles are rewritten by editors, documentation develops naturally, and eventually you have several pages expressing the same idea in different ways.

The exact text matching used in traditional duplicate detection fails as soon as the wording is altered.

In this tutorial, we'll use OpenAI embeddings to create an AI-powered duplicate content detector in Symfony. We'll compare semantic meaning instead of matching keywords, which is the same method that contemporary search engines employ.

For more details : https://www.phpcmsframework.com/2025/12/ai-duplicate-content-detector-for-symfony-with-php-openai.html

AI Category Recommendation System for Drupal 11 Using PHP and OpenAI

PHP CMS Framework — Tue, 23 Dec 2025 05:58:48 +0000

In Drupal, choosing the right category for a page or article is very important. However, in real life, people can make mistakes. Editors may pick the wrong category, use different categories for similar content, or publish posts quickly without giving much thought to categorization.

AI-powered Drupal 11 can now recommend the best category for a node. Instead of depending only on keywords, this recommendation is based on the node's actual content.

For more information: https://www.phpcmsframework.com/2025/12/ai-category-recommendation-system-for-drupal-11.html

AI Auto-Tagging in Laravel Using OpenAI Embeddings + Cron Jobs

PHP CMS Framework — Tue, 09 Dec 2025 13:27:19 +0000

It is tedious, inconsistent, and frequently incorrect to manually tag blog posts. With AI embeddings, Laravel can automatically determine the topic of a blog post and assign the appropriate tags without the need for human intervention.

For more details: https://www.phpcmsframework.com/2025/12/ai-auto-tagging-in-laravel-using-openai.html

Building an AI-Powered Product Description Generator in Magento 2 Using PHP & OpenAI

PHP CMS Framework — Tue, 18 Nov 2025 11:49:14 +0000

Writing product descriptions manually is slow, repetitive, and expensive — especially if you manage a large Magento store. But what if Magento could auto-generate SEO-friendly product descriptions using AI?

In this guide, you’ll learn how to integrate OpenAI’s API into Magento 2 to automatically generate product descriptions, short descriptions, and meta tags — directly from the Admin panel.

For more details: https://www.phpcmsframework.com/2025/11/building-ai-powered-product-description-in-magento2-with-openai.html