Skip to content
Mehedi Hasan Sagor

// blog

Integrating Generative AI into Laravel Apps: A Practical Guide for Startups

Mehedi Hasan Sagor Nov 2, 2026 4 min read
Integrating Generative AI into Laravel Apps: A Practical Guide for Startups

Why AI Matters for Modern Products

Startups and agencies are racing to embed intelligence that feels native—auto‑complete text, image generation, recommendation engines, or conversational agents. The barrier is no longer "can I use AI?" but "how do I do it safely, affordably, and maintainably?" This guide shows how to turn a Laravel backend into a trustworthy AI layer, with concrete code, operational tips, and trade‑offs you can act on today.

1. Pick the Right Model and Provider

| Need | Recommended Provider | Typical Cost (per 1 k tokens) | |------|----------------------|-------------------------------| | Text generation (ChatGPT‑like) | OpenAI (gpt‑3.5‑turbo) | $0.002 | | Structured data extraction | Anthropic (claude‑instant) | $0.0015 | | Image generation | Stability AI (stable‑diffusion) | $0.015 | | On‑premise or data‑sensitive workloads | HuggingFace Inference API (self‑hosted) | Varies |

First‑principle rule: start with the cheapest model that meets quality requirements. Run a quick side‑by‑side test (e.g., 5 prompts) and compare output relevance. If the cheaper model fails, step up one tier.

2. Secure API Integration

Laravel ships with HTTP client utilities that make signing requests trivial. Store API keys in the encrypted .env file and never hard‑code them.

<?php
// app/Services/AI/Client.php
namespace App\Services\AI;

use Illuminate\Support\Facades\Http;

class Client
{
    protected $baseUrl;
    protected $apiKey;

    public function __construct()
    {
        $this->baseUrl = config('ai.provider_url');
        $this->apiKey  = config('ai.api_key');
    }

    public function request(string $endpoint, array $payload)
    {
        return Http::withHeaders([
                'Authorization' => "Bearer {$this->apiKey}",
                'Content-Type'  => 'application/json',
            ])
            ->post("{$this->baseUrl}/{$endpoint}", $payload)
            ->throw()
            ->json();
    }
}
?>

Add a dedicated config file config/ai.php so you can swap providers without touching the service class.

<?php
return [
    'provider_url' => env('AI_PROVIDER_URL', 'https://api.openai.com/v1'),
    'api_key'      => env('AI_API_KEY'),
];
?>

Security tip: enable rate‑limiting on the route that triggers AI calls (e.g., ThrottleRequests) to avoid accidental credential abuse.

3. Prompt Engineering & Validation

AI models are deterministic only when the prompt is well‑crafted. Keep prompts short, explicit, and versioned.

<?php
$prompt = <<<PROMPT
You are a helpful assistant that writes concise product descriptions.

Product: {{name}}
Features: {{features}}

Write a 2‑sentence description in a friendly tone.
PROMPT;

$filled = str_replace([
    '{{name}}',
    '{{features}}',
], [
    $product->name,
    implode(', ', $product->features),
], $prompt);
?>

Before sending to the model, validate that placeholders are filled and that the final prompt length stays under the provider’s token limit (typically 4 KB). Use Laravel's validation rules:

$request->validate([
    'name'     => 'required|string|max:100',
    'features' => 'required|array|min:1|max:10',
]);

Why it matters: malformed prompts can produce hallucinations or waste credits.

4. Asynchronous Processing with Queues

Synchronous calls block the HTTP request and lead to poor UX. Offload AI work to a queue and return a job identifier.

<?php
// app/Jobs/GenerateDescription.php
namespace App\Jobs;

use App\Models\Product;
use App\Services\AI\Client;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class GenerateDescription implements ShouldQueue
{
    use Queueable, InteractsWithQueue, SerializesModels;

    protected $productId;

    public function __construct(int $productId)
    {
        $this->productId = $productId;
    }

    public function handle(Client $client)
    {
        $product = Product::findOrFail($this->productId);
        $prompt  = view('ai.prompts.description', compact('product'))->render();

        $response = $client->request('chat/completions', [
            'model' => 'gpt-3.5-turbo',
            'messages' => [['role' => 'user', 'content' => $prompt]],
        ]);

        $product->description = trim($response['choices'][0]['message']['content'] ?? '');
        $product->save();
    }
}
?>

Dispatch the job from a controller:

public function store(Request $request)
{
    $product = Product::create($request->validated());
    GenerateDescription::dispatch($product->id);
    return response()->json(['id' => $product->id, 'status' => 'queued']);
}

Clients poll an endpoint (GET /products/{id}/status) to know when the description is ready.

5. Cost Control & Monitoring

  1. Set a per‑request ceiling – add a max_tokens field to the payload (e.g., 200) to bound spending.
  2. Log every call – a dedicated ai_requests table captures model, prompt_hash, usage, and cost.
  3. Alert on spikes – use Laravel Telescope or a simple scheduled job that sums daily spend and notifies Slack if it exceeds a threshold.
DB::table('ai_requests')->insert([
    'model'       => $model,
    'prompt_hash' => md5($prompt),
    'prompt'      => $prompt,
    'response'    => json_encode($response),
    'usage'       => $response['usage']['total_tokens'],
    'cost_usd'    => $response['usage']['total_tokens'] * 0.000002, // example rate
    'created_at'  => now(),
]);

Trade‑off: detailed logging adds storage cost but is essential for debugging and audit compliance, especially for regulated domains.

6. Deploying and Scaling

  • Environment variables per stage – keep separate API keys for dev, staging, and production.
  • Horizontal queue workers – allocate at least one dedicated worker for AI jobs; monitor latency with Laravel Horizon.
  • Cache hot prompts – if the same prompt repeats (e.g., onboarding wizard), store the AI output in Redis for 24 h to avoid redundant calls.
$cacheKey = 'ai:description:'.$product->id;
$description = Cache::remember($cacheKey, now()->addHours(24), function () use ($client, $prompt) {
    $response = $client->request('chat/completions', [...]);
    return trim($response['choices'][0]['message']['content'] ?? '');
});

When you need to migrate to a self‑hosted model (e.g., an open‑source LLaMA instance), only the Client class changes; the rest of the code remains untouched.

7. Takeaway Checklist

  • Model selection: start cheap, test quality, upgrade only if needed.
  • Secure secrets: use Laravel .env and config files; add rate limiting.
  • Prompt discipline: version prompts, enforce length limits, validate inputs.
  • Queue AI work: avoid blocking requests; return job IDs.
  • Log & monitor: store usage, set spend alerts, review daily.
  • Cache where possible: reduce duplicate calls and cost.
  • Infrastructure parity: keep provider URLs and keys per environment; abstract the HTTP client.

By treating AI as another external service—complete with authentication, throttling, observability, and fallback strategies—you can ship intelligent features without sacrificing reliability or budget.

Next step: implement the GenerateDescription job in a sandbox project, measure token usage for a handful of prompts, and set your first cost‑alert rule. The insight you gain will pay for itself the moment you start scaling.

  • Laravel
  • Api
  • Devops
  • Ai