// Switch between providers seamlessly
$response = (new SalesCoach)->prompt('Analyze this data', provider: 'openai');
// OR
$response = (new SalesCoach)->prompt('Analyze this data', provider: 'anthropic');
// OR
$response = (new SalesCoach)->prompt('Analyze this data', provider: 'gemini');

public function schema(JsonSchema $schema): array
{
    return [
        'summary' => $schema->string()->required(),
        'key_points' => $schema->array()->required(),
        'risk_score' => $schema->integer()->min(1)->max(10)->required(),
        'recommendations' => $schema->array()->required(),
    ];
}

// Usage
$report = (new ReportGenerator)->prompt('Analyze Q3 sales data');
echo $report['summary']; // Structured, predictable output

// Start a new conversation
$response = (new SupportAgent)->forUser($user)->prompt('Hello!');

// Continue later using the conversation ID
$followUp = (new SupportAgent)
    ->continue($conversationId, as: $user)
    ->prompt('Tell me more about that issue.');

Route::get('/ai-assistant', function () {
    return (new ResearchAssistant)->stream('Explain quantum computing');
});

# Install the SDK
composer require laravel/ai

# Publish configuration and migrations
php artisan vendor:publish --provider="Laravel\Ai\AiServiceProvider"

# Run migrations for conversation storage
php artisan migrate

OPENAI_API_KEY=sk-your-key-here
ANTHROPIC_API_KEY=your-anthropic-key
GEMINI_API_KEY=your-gemini-key

php artisan make:agent CustomerSupportAgent --structured

<?php

namespace App\Ai\Agents;

use Illuminate\Contracts\JsonSchema\JsonSchema;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\HasStructuredOutput;
use Laravel\Ai\Promptable;

class CustomerSupportAgent implements Agent, HasStructuredOutput
{
    use Promptable;

    public function instructions(): string
    {
        return 'You are a helpful customer support agent for Acme Corp. ' .
               'Provide concise, accurate answers about our products and services. ' .
               'Always be polite and professional.';
    }

    public function schema(JsonSchema $schema): array
    {
        return [
            'response' => $schema->string()->required(),
            'confidence' => $schema->integer()->min(1)->max(10)->required(),
            'suggested_actions' => $schema->array()->required(),
            'escalate_to_human' => $schema->boolean()->required(),
        ];
    }
}

public function handleSupportRequest(Request $request)
{
    $agent = new CustomerSupportAgent();
    
    $response = $agent->prompt(
        $request->input('message'),
        attachments: $request->hasFile('attachment') 
            ? [$request->file('attachment')] 
            : []
    );
    
    return response()->json([
        'message' => $response['response'],
        'confidence' => $response['confidence'],
        'actions' => $response['suggested_actions'],
        'needs_human' => $response['escalate_to_human'],
    ]);
}

// In your controller
public function chat()
{
    return view('chat', [
        'streamUrl' => route('ai.stream')
    ]);
}

// In routes/web.php
Route::post('/ai/stream', function (Request $request) {
    return (new CustomerSupportAgent)
        ->stream($request->input('message'))
        ->usingVercelDataProtocol();
})->name('ai.stream');

<!-- In your Blade template -->
<div id="chat-container"></div>
<script>
    async function sendMessage(message) {
        const response = await fetch('/ai/stream', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ message })
        });
        
        // Handle streaming response
        const reader = response.body.getReader();
        const decoder = new TextDecoder();
        
        while (true) {
            const { done, value } = await reader.read();
            if (done) break;
            
            const chunk = decoder.decode(value);
            // Process streaming chunks
            document.getElementById('chat-container').innerHTML += chunk;
        }
    }
</script>

php artisan make:tool FetchOrderDetails

<?php

namespace App\Ai\Tools;

use Illuminate\Contracts\JsonSchema\JsonSchema;
use Laravel\Ai\Contracts\Tool;

class FetchOrderDetails implements Tool
{
    public function name(): string
    {
        return 'fetch_order_details';
    }

    public function description(): string
    {
        return 'Fetch order details by order ID';
    }

    public function schema(JsonSchema $schema): array
    {
        return [
            'order_id' => $schema->string()->required(),
        ];
    }

    public function handle(array $arguments): string
    {
        $order = Order::find($arguments['order_id']);
        
        if (!$order) {
            return 'Order not found';
        }
        
        return json_encode([
            'status' => $order->status,
            'total' => $order->total,
            'items' => $order->items->pluck('name'),
            'estimated_delivery' => $order->estimated_delivery,
        ]);
    }
}

// Automatically categorize and route support tickets
$agent = new SupportTicketRouter();
$routing = $agent->prompt($ticketDescription);
$ticket->assignToDepartment($routing['department']);
$ticket->setPriority($routing['priority']);

// Generate and moderate user-generated content
$blogAgent = new BlogAssistant();
$draft = $blogAgent->prompt("Write about Laravel best practices");
$moderated = (new ContentModerator)->prompt($draft);

// Analyze database records and generate insights
$analyst = new DataAnalyst();
$report = $analyst->prompt(
    "Analyze sales trends from the attached data",
    attachments: [Document::fromStorage('sales_q3.csv')]
);

// Create personalized product recommendations
$recommender = new ProductRecommender();
$suggestions = $recommender->forUser($user)->prompt(
    "Based on purchase history, suggest complementary products"
);

// Queue AI operations for better performance
(new ReportGenerator)
    ->queue($largeDataset)
    ->then(function ($report) use ($user) {
        $user->notify(new ReportReadyNotification($report));
    });