DEV Community: Aditya Kumar

Streaming AI Responses in Laravel with Server-Sent Events

Aditya Kumar — Thu, 16 Jul 2026 07:49:29 +0000

In the first post of this series we built a working AI chatbot in Laravel. It had one problem every user notices immediately: you send a message, then stare at a spinner for five seconds while the whole response generates.

LLMs produce text token by token. If you wait for the full completion before showing anything, you're throwing away the single biggest UX win available: streaming. The same answer that takes 5 seconds to finish starts appearing in ~300ms when streamed. Nothing about the model got faster — but to the user, it feels 10x faster.

In this post we'll upgrade the chatbot to stream responses with Server-Sent Events (SSE) — no WebSockets, no Pusher, no extra infrastructure. Just Laravel.

Why SSE and not WebSockets?

WebSockets are bidirectional and need a long-running server (Reverb, Soketi) or a paid service. For chat completions you only need one direction: server → browser, for the lifetime of one request. That's exactly what SSE is for, and since Laravel 11 it's built into the framework as response()->eventStream().

Rule of thumb: presence, typing indicators, multiplayer → WebSockets. Streaming one AI answer → SSE.

1. Stream from the OpenAI client

We keep the ChatService from part 1 and add a streaming method. The openai-php client exposes createStreamed(), which returns an iterator of deltas:

<?php

namespace App\Services;

use Generator;
use OpenAI\Laravel\Facades\OpenAI;

class ChatService
{
    // ... SYSTEM_PROMPT and reply() from part 1 ...

    /**
     * @param array<int, array{role: string, content: string}> $history
     */
    public function streamReply(array $history, string $userMessage): Generator
    {
        $stream = OpenAI::chat()->createStreamed([
            'model' => 'gpt-4o-mini',
            'messages' => [
                ['role' => 'system', 'content' => self::SYSTEM_PROMPT],
                ...$history,
                ['role' => 'user', 'content' => $userMessage],
            ],
            'max_tokens' => 500,
        ]);

        foreach ($stream as $response) {
            $delta = $response->choices[0]->delta->content;

            if ($delta !== null) {
                yield $delta;
            }
        }
    }
}

A Generator is the right return type here: the controller can forward chunks as they arrive without ever holding the full response in memory.

2. The streaming controller

Laravel 11.19+ ships response()->eventStream(), which handles the SSE formatting (event: / data: lines) for you:

<?php

namespace App\Http\Controllers;

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

class ChatStreamController extends Controller
{
    public function __invoke(Request $request, ChatService $chat)
    {
        $validated = $request->validate([
            'message' => ['required', 'string', 'max:2000'],
        ]);

        $history = $request->session()->get('chat_history', []);

        // CRITICAL: release the session lock. A streaming response is a
        // long-lived request — with the default file/database session
        // driver it would block every other request from this user
        // (including page loads!) until the stream finishes.
        $request->session()->save();

        return response()->eventStream(function () use ($request, $chat, $history, $validated) {
            $full = '';

            foreach ($chat->streamReply($history, $validated['message']) as $chunk) {
                $full .= $chunk;
                yield $chunk;
            }

            // persist history once the stream completes
            $history[] = ['role' => 'user', 'content' => $validated['message']];
            $history[] = ['role' => 'assistant', 'content' => $full];
            $request->session()->put('chat_history', array_slice($history, -20));
            $request->session()->save();
        }, headers: [
            'X-Accel-Buffering' => 'no', // tell nginx not to buffer the stream
        ]);
    }
}

Route it with the same throttling as part 1:

Route::post('/chat/stream', ChatStreamController::class)
    ->middleware(['auth', 'throttle:20,1']);

3. Reading the stream in the browser

The native EventSource API only supports GET requests, and we need to POST a message body — so we read the stream with fetch instead:

<script>
async function streamChat(message, botEl) {
    const res = await fetch('/chat/stream', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]').content,
        },
        body: JSON.stringify({ message }),
    });

    const reader = res.body.getReader();
    const decoder = new TextDecoder();
    let buffer = '';

    while (true) {
        const { done, value } = await reader.read();
        if (done) break;

        buffer += decoder.decode(value, { stream: true });

        // SSE messages are separated by a blank line
        const events = buffer.split('\n\n');
        buffer = events.pop(); // keep the incomplete tail

        for (const evt of events) {
            const data = evt.split('\n')
                .filter(l => l.startsWith('data: '))
                .map(l => l.slice(6))
                .join('\n');

            if (data && data !== '</stream>') {
                botEl.textContent += data;
            }
        }
    }
}
</script>

</stream> is Laravel's default end-of-stream marker — filter it out (or customize it with the endStreamWith argument).

That's it. Send a message and watch the answer type itself out.

Where streaming breaks in production

This is the part most tutorials skip. Streaming works instantly on php artisan serve, then mysteriously arrives all-at-once on your server. The culprit is always buffering somewhere between PHP and the browser:

nginx buffers proxied responses by default. The X-Accel-Buffering: no header above disables it per-response; alternatively set proxy_buffering off; for the route.
PHP-FPM + output buffering: check output_buffering in php.ini. Laravel's eventStream flushes after every yield, but an outer buffer can still swallow it.
Cloudflare / load balancers: most respect SSE content types, but verify with curl -N against production before blaming your code.

Debug tip: curl -N -X POST https://yourapp.test/chat/stream ... shows you exactly what arrives and when, with no browser magic in between.

Production checklist

Release the session lock before streaming (done above) — this is the #1 "my app hangs" bug with SSE in Laravel.
X-Accel-Buffering: no header for nginx (done above).
Timeouts: a stream can outlive max_execution_time and your web server's send timeout. Set both above your worst-case generation time (60s is a sane ceiling with max_tokens: 500).
Mid-stream errors: wrap the generator loop in try/catch and yield a friendly "Something went wrong" chunk — a dead stream with no message looks frozen to users.
Rate limit the endpoint (done above) — streaming doesn't change the fact that every request costs money.
Don't stream everything: for background jobs or short answers, the buffered endpoint from part 1 is simpler. Keep both.

Next in this series

Our bot streams beautifully, but it still only knows what's in its system prompt. Next up: RAG in Laravel — embeddings and pgvector, where we'll give it your actual documentation to answer from. Follow me to catch it.

I'm Aditya Kumar (adityakdevin) — Tech Lead & full-stack developer building AI-powered web products with Laravel, Vue, and LLM APIs. Find me at adityadev.in.

Adding an AI Chatbot to Your Laravel App with the OpenAI API

Aditya Kumar — Thu, 16 Jul 2026 07:32:50 +0000

Every product I've worked on in the last two years has eventually gotten the same request: "Can we add an AI assistant to this?" As a Laravel developer, the good news is that shipping a production-ready chatbot takes an afternoon — no Python microservice, no LangChain, just Laravel and an HTTP API.

In this tutorial we'll build a chatbot that:

answers questions in the context of your product (via a system prompt),
remembers the conversation within a session,
streams nothing fancy — just clean JSON in/out you can drop into any Blade view or SPA.

1. Install the OpenAI PHP client

The community-maintained openai-php/laravel package is the de-facto standard:

composer require openai-php/laravel
php artisan openai:install

Add your key to .env:

OPENAI_API_KEY=sk-your-key-here

💡 Never commit the key. Use your host's secret manager in production.

2. A dedicated chat service

Keep the LLM logic out of your controller. Create app/Services/ChatService.php:

<?php

namespace App\Services;

use OpenAI\Laravel\Facades\OpenAI;

class ChatService
{
    private const SYSTEM_PROMPT = <<<'PROMPT'
        You are the helpful assistant for Acme Inc's customer portal.
        Answer only questions about the product. Be concise.
        If you don't know the answer, say so and suggest contacting support.
        PROMPT;

    /**
     * @param array<int, array{role: string, content: string}> $history
     */
    public function reply(array $history, string $userMessage): string
    {
        $messages = [
            ['role' => 'system', 'content' => self::SYSTEM_PROMPT],
            ...$history,
            ['role' => 'user', 'content' => $userMessage],
        ];

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

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

3. The controller

Session-based history keeps things simple — no migrations needed for v1:

<?php

namespace App\Http\Controllers;

use App\Services\ChatService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class ChatController extends Controller
{
    public function __invoke(Request $request, ChatService $chat): JsonResponse
    {
        $validated = $request->validate([
            'message' => ['required', 'string', 'max:2000'],
        ]);

        $history = $request->session()->get('chat_history', []);

        $answer = $chat->reply($history, $validated['message']);

        // keep the last 10 exchanges to control token costs
        $history[] = ['role' => 'user', 'content' => $validated['message']];
        $history[] = ['role' => 'assistant', 'content' => $answer];
        $request->session()->put('chat_history', array_slice($history, -20));

        return response()->json(['answer' => $answer]);
    }
}

Route it — with rate limiting, because every request costs you money:

// routes/web.php
use App\Http\Controllers\ChatController;

Route::post('/chat', ChatController::class)
    ->middleware(['auth', 'throttle:20,1']); // 20 req/min per user

4. A minimal frontend

Drop this into any Blade view — no framework required:

<div id="chat">
    <div id="messages"></div>
    <form id="chat-form">
        <input id="chat-input" type="text" placeholder="Ask me anything…" required />
        <button type="submit">Send</button>
    </form>
</div>

<script>
document.getElementById('chat-form').addEventListener('submit', async (e) => {
    e.preventDefault();
    const input = document.getElementById('chat-input');
    const messages = document.getElementById('messages');

    messages.insertAdjacentHTML('beforeend', `<p><b>You:</b> ${input.value}</p>`);

    const res = await fetch('/chat', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]').content,
        },
        body: JSON.stringify({ message: input.value }),
    });

    const { answer } = await res.json();
    messages.insertAdjacentHTML('beforeend', `<p><b>Bot:</b> ${answer}</p>`);
    input.value = '';
});
</script>

5. Production checklist

Before you ship this to real users:

Rate limit (done above) — an unthrottled chat endpoint is an open wallet.
Cap history (done above) — token usage grows with every message otherwise.
Validate input length (done above) — 2000 chars is plenty for a question.
Log conversations — a simple chat_logs table pays for itself the first time you debug a weird answer.
Set max_tokens — bounds your worst-case cost per request.
Add a fallback — wrap the API call in a try/catch and return "I'm having trouble right now" instead of a 500.

Where to go next

Streaming responses — OpenAI::chat()->createStreamed() + Server-Sent Events makes the bot feel 10x faster.
RAG (Retrieval-Augmented Generation) — embed your docs and inject relevant chunks into the system prompt so the bot answers from your knowledge base. That's my next post.
Swap providers — the same pattern works with Anthropic's Claude API; only the HTTP client changes.

I'm Aditya Kumar (adityakdevin) — Tech Lead & full-stack developer building AI-powered web products with Laravel, Vue, and LLM APIs. Find me at adityadev.in.