PHP et Laravel

composer require valais-connect/gaspard

use ValaisConnect\Gaspard\Gaspard;

$gaspard = new Gaspard(apiKey: getenv('GASPARD_API_KEY')); // clé serveur vck_live_…

$conversation = $gaspard->startConversation(locale: 'fr', page: 'accueil');
$answer = $gaspard->ask($conversation->id, 'Comment trouver un logement étudiant à Lyon ?');

echo $answer->text, PHP_EOL;
foreach ($answer->sources as $source) {
    echo "- {$source->name} {$source->url}", PHP_EOL;
}

$stream = $gaspard->askStream($conversation->id, 'Que faire à Montréal ce week-end ?');

foreach ($stream as $event) {
    if ($event->isDelta()) {
        echo $event->text;          // un morceau de la réponse
    }
}

$answer = $stream->getReturn();     // Answer : texte complet, sources, offres (listings)…

use ValaisConnect\Gaspard\Topic;

$results = $gaspard->searchKnowledge('Berlin Universitäten', limit: 3, topics: [Topic::EDUCATION, Topic::HISTORY]);

foreach ($results as $passage) {       // SearchResults est itérable et dénombrable
    printf("%.2f %s — %s\n", $passage->score, $passage->title, $passage->source?->name);
}

GASPARD_API_KEY=vck_live_xxxxxxxxxxxxxxxx
# Facultatif :
GASPARD_BASE_URL=https://hubmix.dealmood-solutions.com
GASPARD_TIMEOUT=60
GASPARD_MAX_RETRIES=2

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

use ValaisConnect\Gaspard\Gaspard as GaspardClient;
use ValaisConnect\Gaspard\Laravel\Facades\Gaspard;

// Façade
$notice = Gaspard::privacyNotice('fr');

// Injection
public function __construct(private GaspardClient $gaspard) {}

$gaspard = Gaspard::forEndUser((string) auth()->id());

<?php

namespace App\Http\Controllers;

use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\StreamedResponse;
use ValaisConnect\Gaspard\GaspardException;
use ValaisConnect\Gaspard\Laravel\Facades\Gaspard;

class AssistantController extends Controller
{
    public function start(Request $request): JsonResponse
    {
        $conversation = Gaspard::forEndUser((string) $request->user()->id)
            ->startConversation(locale: app()->getLocale(), page: 'aide');

        return response()->json($conversation); // les objets du SDK sont JsonSerializable
    }

    public function ask(Request $request, string $conversation): StreamedResponse
    {
        $data = $request->validate(['text' => ['required', 'string', 'max:2000']]);
        $user = $request->user();
        $gaspard = Gaspard::forEndUser((string) $user->id);

        return response()->stream(function () use ($gaspard, $conversation, $data, $user): void {
            $send = static function (string $event, array $payload): void {
                echo "event: {$event}\ndata: " . json_encode($payload, JSON_UNESCAPED_UNICODE) . "\n\n";
                if (ob_get_level() > 0) {
                    ob_flush();
                }
                flush();
            };

            try {
                foreach ($gaspard->askStream($conversation, $data['text'], $user->first_name) as $event) {
                    if ($event->isDelta()) {
                        $send('delta', ['text' => $event->text]);
                    } else {
                        $send('answer', $event->answer->toArray());
                    }
                }
            } catch (GaspardException $error) {
                report($error);
                $send('error', ['code' => $error->errorCode]);
            }
        }, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'X-Accel-Buffering' => 'no', // nginx : ne pas mettre le flux en tampon
        ]);
    }
}

// routes/web.php
Route::middleware('auth')->group(function () {
    Route::post('/assistant/conversations', [AssistantController::class, 'start']);
    Route::post('/assistant/conversations/{conversation}/messages', [AssistantController::class, 'ask']);
});

const response = await fetch(`/assistant/conversations/${id}/messages`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'X-CSRF-TOKEN': csrfToken },
  body: JSON.stringify({ text }),
});
const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
let buffer = '';
for (;;) {
  const { value, done } = await reader.read();
  if (done) break;
  buffer += value;
  let end;
  while ((end = buffer.indexOf('\n\n')) >= 0) {
    const block = buffer.slice(0, end);
    buffer = buffer.slice(end + 2);
    const event = /^event: (.*)$/m.exec(block)?.[1];
    const data = JSON.parse(/^data: (.*)$/m.exec(block)?.[1] ?? 'null');
    if (event === 'delta') output.textContent += data.text;
    if (event === 'answer') showSources(data.sources);
    if (event === 'error') showError(data.code);
  }
}

use ValaisConnect\Gaspard\Laravel\Facades\Gaspard;
use ValaisConnect\Gaspard\Model\PrivacyNotice;

Gaspard::shouldReceive('privacyNotice')->once()->andReturn(new PrivacyNotice('2026-10', 'Texte…', 365));

$gaspard = new Gaspard(publishableKey: 'vcp_live_…', origin: 'https://mon-app.example.ch');

$notice = $gaspard->privacyNotice('fr');
// … afficher $notice->text et recueillir l'accord du visiteur …

$session = $gaspard->openSession(consent: true, allowTraining: false);
saveSomewhere($session->token);                   // valable 30 jours

// Plus tard : reprendre la même session
$gaspard->setVisitorToken(loadFromSomewhere());   // ou null pour l'oublier
$conversation = $gaspard->startConversation();

$user = Gaspard::forEndUser((string) auth()->id());

$notice = $user->privacyNotice();
$user->giveConsent($notice->version, allowTraining: true); // après acceptation de $notice->text
$status = $user->consent();          // ConsentStatus : given, upToDate, noticeVersion…
$user->withdrawConsent();
$data = $user->exportData();         // VisitorData : droit d'accès
$erasure = $user->eraseData();       // Erasure : droit à l'effacement

use ValaisConnect\Gaspard\GaspardException;

try {
    $answer = $gaspard->ask($conversationId, $question);
} catch (GaspardException $error) {
    match ($error->errorCode) {
        'conversation_full' => $conversationId = $gaspard->startConversation()->id,
        'token_quota_exceeded' => logger()->warning("Quota atteint, réessayer dans {$error->retryAfter} s"),
        default => report($error),
    };
}

use ValaisConnect\Gaspard\Laravel\Facades\Gaspard;

// Confiance : à la publication d'une annonce
$result = Gaspard::trust()->assess([[
    'kind' => 'housing',
    'title' => $listing->title,
    'description' => $listing->description,
    'price_amount' => $listing->rent,
    'currency' => 'EUR',
    'country_code' => 'FR',
    'city' => 'Lyon',
]]);
if ($result->assessments[0]->withheld) {
    $listing->holdForReview($result->assessments[0]->findings);
}

// Tuteur : un quiz sur un cours
$quiz = Gaspard::tutor()->quiz(
    lesson: ['title' => 'La photosynthèse', 'content' => $course->text],
    count: 5,
    difficulty: 'medium',
    learner: ['level' => 'bachelor', 'country_code' => 'SN'],
    locale: 'fr',
);

// Embeddings : un vecteur par texte, dans le même ordre
$vectors = Gaspard::embeddings()->create(['chambre à louer', 'room for rent'])->embeddings;