PHP code example of google-gemini-php / laravel

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

google-gemini-php / laravel example snippets

use Gemini\Enums\ModelVariation;
use Gemini\GeminiHelper;
use Gemini\Laravel\Facades\Gemini;

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')->generateContent('Hello');
$result->text(); // Hello! How can I assist you today?

// Helper method usage
$result = Gemini::generativeModel(
    model: GeminiHelper::generateGeminiModel(
        variation: ModelVariation::FLASH,
        generation: 2.5,
    ), // models/gemini-2.5-flash
)->generateContent('Hello');
$result->text(); // Hello! How can I assist you today?

use Gemini\Contracts\ClientContract;

class SummaryController
{
    public function __invoke(ClientContract $gemini): string
    {
        return $gemini->generativeModel(model: 'gemini-2.5-flash')->generateContent('Hello')->text();
    }
}

use Gemini\Laravel\Facades\Gemini;

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')->generateContent('Hello');

$result->text(); // Hello! How can I assist you today?

use Gemini\Data\Blob;
use Gemini\Enums\MimeType;
use Gemini\Laravel\Facades\Gemini;

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->generateContent([
        'What is this picture?',
        new Blob(
            mimeType: MimeType::IMAGE_JPEG,
            data: base64_encode(
                file_get_contents('https://storage.googleapis.com/generativeai-downloads/images/scones.jpg')
            )
        )
    ]);

$result->text(); //  The picture shows a table with a white tablecloth. On the table are two cups of coffee, a bowl of blueberries, a silver spoon, and some flowers. There are also some blueberry scones on the table.

use Gemini\Data\UploadedFile;
use Gemini\Enums\MimeType;
use Gemini\Laravel\Facades\Gemini;

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->generateContent([
        'What is this video?',
        new UploadedFile(
            fileUri: $meta->uri, // the URI of the uploaded file, e.g. https://generativelanguage.googleapis.com/v1beta/files/abc-123
            mimeType: MimeType::VIDEO_MP4
        )
    ]);

$result->text(); //  The video shows...

use Gemini\Data\Blob;
use Gemini\Data\Content;
use Gemini\Data\Part;
use Gemini\Data\PartMediaResolution;
use Gemini\Enums\MimeType;
use Gemini\Enums\PartMediaResolutionLevel;
use Gemini\Enums\Role;
use Gemini\Laravel\Facades\Gemini;

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->generateContent(new Content(
        parts: [
            new Part(
                inlineData: new Blob(mimeType: MimeType::IMAGE_PNG, data: base64_encode(file_get_contents('chart.png'))),
                mediaResolution: new PartMediaResolution(level: PartMediaResolutionLevel::MEDIA_RESOLUTION_HIGH),
            ),
            new Part(text: 'Read the values from this chart.'),
        ],
        role: Role::USER,
    ));

$result->text();

use Gemini\Data\GenerationConfig;
use Gemini\Data\ImageConfig;
use Gemini\Laravel\Facades\Gemini;

$imageConfig = new ImageConfig(aspectRatio: '16:9', imageSize: '2K');
$generationConfig = new GenerationConfig(imageConfig: $imageConfig);

$response = Gemini::generativeModel(model: 'gemini-2.5-flash-image')
    ->withGenerationConfig($generationConfig)
    ->generateContent('Draw a futuristic city');

// The response can contain text and image parts
foreach ($response->parts() as $part) {
    if ($part->inlineData !== null) {
        file_put_contents('image.png', base64_decode($part->inlineData->data));
    }
}

use Gemini\Data\Content;
use Gemini\Enums\Role;
use Gemini\Laravel\Facades\Gemini;

$chat = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->startChat(history: [
        Content::parse(part: 'The stories you write about what I have to say should be one line. Is that clear?'),
        Content::parse(part: 'Yes, I understand. The stories I write about your input should be one line long.', role: Role::MODEL)
    ]);

$response = $chat->sendMessage('Create a story set in a quiet village in 1600s France');
echo $response->text(); // Amidst rolling hills and winding cobblestone streets, the tranquil village of Beausoleil whispered tales of love, intrigue, and the magic of everyday life in 17th century France.

$response = $chat->sendMessage('Rewrite the same story in 1600s England');
echo $response->text(); // In the heart of England's lush countryside, amidst emerald fields and thatched-roof cottages, the village of Willowbrook unfolded a tapestry of love, mystery, and the enchantment of ordinary days in the 17th century.

$chat->history; // array<Content>

use Gemini\Laravel\Facades\Gemini;

$chat = Gemini::generativeModel(model: 'gemini-2.5-flash')->startChat();

$stream = $chat->streamSendMessage('Hello');

foreach ($stream as $response) {
    echo $response->text();
}

use Gemini\Laravel\Facades\Gemini;

$stream = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->streamGenerateContent('Write a long story about a magic backpack.');

foreach ($stream as $response) {
    echo $response->text();
}

use Gemini\Data\GenerationConfig;
use Gemini\Data\Schema;
use Gemini\Enums\DataType;
use Gemini\Enums\ResponseMimeType;
use Gemini\Laravel\Facades\Gemini;

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withGenerationConfig(
        generationConfig: new GenerationConfig(
            responseMimeType: ResponseMimeType::APPLICATION_JSON,
            responseSchema: new Schema(
                type: DataType::ARRAY,
                items: new Schema(
                    type: DataType::OBJECT,
                    properties: [
                        'recipe_name' => new Schema(type: DataType::STRING),
                        'cooking_time_in_minutes' => new Schema(type: DataType::INTEGER)
                    ],
                    

use Gemini\Data\GenerationConfig;
use Gemini\Enums\ResponseMimeType;
use Gemini\Laravel\Facades\Gemini;

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withGenerationConfig(new GenerationConfig(
        responseMimeType: ResponseMimeType::APPLICATION_JSON,
        responseJsonSchema: [
            'type' => 'object',
            'properties' => [
                'city' => ['type' => 'string'],
                'population' => ['type' => 'integer', 'minimum' => 0],
            ],
            '

use Gemini\Data\Content;
use Gemini\Data\FunctionCall;
use Gemini\Data\FunctionDeclaration;
use Gemini\Data\FunctionResponse;
use Gemini\Data\Part;
use Gemini\Data\Schema;
use Gemini\Data\Tool;
use Gemini\Enums\DataType;
use Gemini\Enums\Role;
use Gemini\Laravel\Facades\Gemini;

function handleFunctionCall(FunctionCall $functionCall): Content
{
    if ($functionCall->name === 'addition') {
        return new Content(
            parts: [
                new Part(
                    functionResponse: new FunctionResponse(
                        name: 'addition',
                        response: ['answer' => $functionCall->args['number1'] + $functionCall->args['number2']],
                        id: $functionCall->id,
                    )
                )
            ],
            role: Role::USER
        );
    }

    //Handle other function calls
}

$chat = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withTool(new Tool(
        functionDeclarations: [
            new FunctionDeclaration(
                name: 'addition',
                description: 'Performs addition',
                parameters: new Schema(
                    type: DataType::OBJECT,
                    properties: [
                        'number1' => new Schema(
                            type: DataType::NUMBER,
                            description: 'First number'
                        ),
                        'number2' => new Schema(
                            type: DataType::NUMBER,
                            description: 'Second number'
                        ),
                    ],
                    

use Gemini\Data\FunctionDeclaration;

new FunctionDeclaration(
    name: 'get_weather',
    description: 'Returns the weather for a city.',
    parametersJsonSchema: [
        'type' => 'object',
        'properties' => [
            'city' => ['type' => 'string'],
            'unit' => ['type' => 'string', 'enum' => ['celsius', 'fahrenheit']],
        ],
        '

use Gemini\Data\Blob;
use Gemini\Data\Content;
use Gemini\Data\FunctionResponse;
use Gemini\Data\FunctionResponsePart;
use Gemini\Data\Part;
use Gemini\Enums\MimeType;
use Gemini\Enums\Role;

$response = $chat->sendMessage(new Content(
    parts: [
        new Part(functionResponse: new FunctionResponse(
            name: $functionCall->name,
            response: ['image' => 'product.png'],
            id: $functionCall->id,
            parts: [
                new FunctionResponsePart(inlineData: new Blob(mimeType: MimeType::IMAGE_PNG, data: base64_encode($png))),
            ],
        )),
    ],
    role: Role::USER,
));

use Gemini\Data\CodeExecution;
use Gemini\Data\Tool;
use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withTool(new Tool(codeExecution: CodeExecution::from()))
    ->generateContent('What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50.');

// Access the executed code and results
foreach ($response->parts() as $part) {
    if ($part->executableCode !== null) {
        echo "Language: " . $part->executableCode->language->value . "\n";
        echo "Code: " . $part->executableCode->code . "\n";
    }
    if ($part->codeExecutionResult !== null) {
        echo "Outcome: " . $part->codeExecutionResult->outcome->value . "\n";
        echo "Output: " . $part->codeExecutionResult->output . "\n";
    }
}

use Gemini\Data\GoogleSearch;
use Gemini\Data\Tool;
use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withTool(new Tool(googleSearch: GoogleSearch::from()))
    ->generateContent('Who won the Euro 2024?');

echo $response->text();
// Spain won Euro 2024, defeating England 2-1 in the final.

// Access grounding metadata to see sources
$groundingMetadata = $response->candidates[0]->groundingMetadata;
if ($groundingMetadata !== null) {
    // Get the search queries that were executed
    foreach ($groundingMetadata->webSearchQueries ?? [] as $query) {
        echo "Search query: {$query}\n";
    }
    
    // Get the web sources
    foreach ($groundingMetadata->groundingChunks ?? [] as $chunk) {
        if ($chunk->web !== null) {
            echo "Source: {$chunk->web->title} - {$chunk->web->uri}\n";
        }
    }
    
    // Get grounding supports (links text segments to sources)
    foreach ($groundingMetadata->groundingSupports ?? [] as $support) {
        if ($support->segment !== null) {
            echo "Text segment: {$support->segment->text}\n";
            echo "Supported by chunks: " . implode(', ', $support->groundingChunkIndices ?? []) . "\n";
        }
    }
}

use Gemini\Data\GoogleMaps;
use Gemini\Data\RetrievalConfig;
use Gemini\Data\Tool;
use Gemini\Data\ToolConfig;
use Gemini\Laravel\Facades\Gemini;

$tool = new Tool(
    googleMaps: new GoogleMaps(enableWidget: true)
);

$toolConfig = new ToolConfig(
    retrievalConfig: new RetrievalConfig(
        latitude: 40.758896,
        longitude: -73.985130
    )
);

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withTool($tool)
    ->withToolConfig($toolConfig)
    ->generateContent('Find coffee shops near me');

echo $response->text();
// (Model output referencing coffee shops)

use Gemini\Data\FileSearch;
use Gemini\Data\Tool;
use Gemini\Laravel\Facades\Gemini;

$tool = new Tool(
    fileSearch: new FileSearch(
        fileSearchStoreNames: ['fileSearchStores/my-search-store'],
        metadataFilter: 'author = "Robert Graves"'
    )
);

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withTool($tool)
    ->generateContent('Summarize the document about Greek myths by Robert Graves');

echo $response->text();
// (Model output summarizing the document)

use Gemini\Data\Tool;
use Gemini\Data\UrlContext;
use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withTool(new Tool(urlContext: new UrlContext))
    ->generateContent('Summarize https://www.php.net/releases/8.4/en.php in one sentence.');

echo $response->text();

// Check which URLs were retrieved
foreach ($response->candidates[0]->urlContextMetadata?->urlMetadata ?? [] as $urlMetadata) {
    echo "{$urlMetadata->retrievedUrl}: {$urlMetadata->urlRetrievalStatus?->value}\n"; // URL_RETRIEVAL_STATUS_SUCCESS
}

use Gemini\Data\Tool;
use Gemini\Data\ToolConfig;
use Gemini\Data\UrlContext;
use Gemini\Laravel\Facades\Gemini;

$chat = Gemini::generativeModel(model: 'gemini-3.5-flash')
    ->withTool(new Tool(urlContext: new UrlContext))
    ->withToolConfig(new ToolConfig( . json_encode($part->toolCall->args) . "\n";
    }
    if ($part->toolResponse !== null) {
        echo "Tool response: " . json_encode($part->toolResponse->response) . "\n";
    }
    if ($part->text !== null) {
        echo $part->text . "\n";
    }
}

use Gemini\Data\Content;
use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withSystemInstruction(
        Content::parse('You are a helpful assistant that always responds in the style of a pirate. Use nautical terms and pirate slang in all your responses.')
    )
    ->generateContent('Tell me about PHP programming');

echo $response->text();
// Ahoy there, matey! Let me tell ye about this fine treasure called PHP programming...

use Gemini\Data\Content;
use Gemini\Data\GenerationConfig;
use Gemini\Enums\ResponseMimeType;
use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withSystemInstruction(
        Content::parse('You are a JSON API. Always respond with valid JSON objects. Be concise.')
    )
    ->withGenerationConfig(
        new GenerationConfig(responseMimeType: ResponseMimeType::APPLICATION_JSON)
    )
    ->generateContent('Give me information about the Eiffel Tower');

print_r($response->json());

use Gemini\Data\GenerationConfig;
use Gemini\Data\PrebuiltVoiceConfig;
use Gemini\Data\SpeechConfig;
use Gemini\Data\VoiceConfig;
use Gemini\Enums\ResponseModality;
use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel('gemini-2.5-flash-preview-tts')->withGenerationConfig(
    generationConfig: new GenerationConfig(
        responseModalities: [ResponseModality::AUDIO],
        speechConfig: new SpeechConfig(
            voiceConfig: new VoiceConfig(
                new PrebuiltVoiceConfig(voiceName: 'Kore')
            ),
        )
    )
)->generateContent("Say: Hello world");

// The response contains base64 encoded audio
$audio = $response->parts()[0]->inlineData;
$audio->mimeType; // e.g. MimeType::AUDIO_L16_PCM_RATE_24000 (raw 16-bit PCM, 24 kHz, mono)
$audioData = base64_decode($audio->data);

use Gemini\Data\GenerationConfig;
use Gemini\Data\MultiSpeakerVoiceConfig;
use Gemini\Data\PrebuiltVoiceConfig;
use Gemini\Data\SpeakerVoiceConfig;
use Gemini\Data\SpeechConfig;
use Gemini\Data\VoiceConfig;
use Gemini\Enums\ResponseModality;
use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel('gemini-2.5-flash-preview-tts')->withGenerationConfig(
    generationConfig: new GenerationConfig(
        responseModalities: [ResponseModality::AUDIO],
        speechConfig: new SpeechConfig(
            multiSpeakerVoiceConfig: new MultiSpeakerVoiceConfig([
                new SpeakerVoiceConfig(
                    speaker: 'Joe',
                    voiceConfig: new VoiceConfig(
                        new PrebuiltVoiceConfig('Kore'),
                    )
                ),
                new SpeakerVoiceConfig(
                    speaker: 'Jane',
                    voiceConfig: new VoiceConfig(
                        new PrebuiltVoiceConfig('Puck'),
                    )
                )
            ]),
            languageCode: 'en-GB'
        )
    )
)->generateContent("TTS the following conversation between Joe and Jane:\nJoe: How's it going today Jane?\nJane: Not too bad, how about you?");

// The response contains base64 encoded audio
$audioData = $response->parts()[0]->inlineData->data;

use Gemini\Data\GenerationConfig;
use Gemini\Data\ThinkingConfig;
use Gemini\Enums\ThinkingLevel;
use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withGenerationConfig(
        new GenerationConfig(
            thinkingConfig: new ThinkingConfig(
                onse->parts() as $part) {
    if ($part->thought === true) {
        // This part contains a summary of the model's thinking process
        echo "Model's thinking: " . $part->text . "\n\n";
    } else if ($part->text !== null) {
        // This is the final answer
        echo "Final answer: " . $part->text . "\n";
    }
}

echo $response->usageMetadata->thoughtsTokenCount; // tokens used for thinking

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->countTokens('Write a story about a magic backpack.');

echo $response->totalTokens; // 9

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')->generateContent('Hello');

$response->responseId; // PqnIaobZOf3fxs0PkPSdiAk
$response->modelVersion; // gemini-2.5-flash
$response->modelStatus?->modelStage; // e.g. ModelStage::PREVIEW, when the API reports it

$response->usageMetadata->promptTokenCount; // 1
$response->usageMetadata->candidatesTokenCount; // 9
$response->usageMetadata->thoughtsTokenCount; // 20
$response->usageMetadata->totalTokenCount; // 30
$response->usageMetadata->serviceTier; // ServiceTier::STANDARD

$response->candidates[0]->finishReason; // FinishReason::STOP
$response->candidates[0]->finishMessage; // details on why the model stopped, when available
$response->candidates[0]->safetyRatings; // array<SafetyRating>

use Gemini\Data\GenerationConfig;
use Gemini\Data\SafetySetting;
use Gemini\Enums\HarmBlockThreshold;
use Gemini\Enums\HarmCategory;
use Gemini\Laravel\Facades\Gemini;

$safetySettingDangerousContent = new SafetySetting(
    category: HarmCategory::HARM_CATEGORY_DANGEROUS_CONTENT,
    threshold: HarmBlockThreshold::BLOCK_ONLY_HIGH
);

$safetySettingHateSpeech = new SafetySetting(
    category: HarmCategory::HARM_CATEGORY_HATE_SPEECH,
    threshold: HarmBlockThreshold::BLOCK_ONLY_HIGH
);

$generationConfig = new GenerationConfig(
    stopSequences: [
        'Title',
    ],
    maxOutputTokens: 800,
    temperature: 1,
    topP: 0.8,
    topK: 10
);

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withSafetySetting($safetySettingDangerousContent)
    ->withSafetySetting($safetySettingHateSpeech)
    ->withGenerationConfig($generationConfig)
    ->generateContent('Write a story about a magic backpack.');

use Gemini\Enums\FileState;
use Gemini\Enums\MimeType;
use Gemini\Laravel\Facades\Gemini;

$files = Gemini::files();
echo "Uploading\n";
$meta = $files->upload(
    filename: 'video.mp4',
    mimeType: MimeType::VIDEO_MP4,
    displayName: 'Video'
);
echo "Processing";
do {
    echo ".";
    sleep(2);
    $meta = $files->metadataGet($meta->uri);
} while (!$meta->state->complete());
echo "\n";

if ($meta->state == FileState::Failed) {
    die("Upload failed:\n" . json_encode($meta->toArray(), JSON_PRETTY_PRINT));
}

echo "Processing complete\n" . json_encode($meta->toArray(), JSON_PRETTY_PRINT);
echo "\n{$meta->uri}";

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::files()->list(pageSize: 10);

foreach ($response->files as $file) {
    echo "Name: {$file->name}\n";
    echo "Display Name: {$file->displayName}\n";
    echo "Size: {$file->sizeBytes} bytes\n";
    echo "MIME Type: {$file->mimeType}\n";
    echo "State: {$file->state->value}\n";
    echo "---\n";
}

// Get next page if available
if ($response->nextPageToken) {
    $nextPage = Gemini::files()->list(pageSize: 10, nextPageToken: $response->nextPageToken);
}

use Gemini\Laravel\Facades\Gemini;

$meta = Gemini::files()->metadataGet('abc-123');
// or use the name
$meta = Gemini::files()->metadataGet('files/abc-123');
// or use the full URI
$meta = Gemini::files()->metadataGet($file->uri);

echo "File: {$meta->displayName}\n";
echo "State: {$meta->state->value}\n";
echo "Size: {$meta->sizeBytes} bytes\n";

use Gemini\Laravel\Facades\Gemini;

Gemini::files()->delete('files/abc-123');
// or use the full URI
Gemini::files()->delete($file->uri);

use Gemini\Data\Content;
use Gemini\Laravel\Facades\Gemini;

$cachedContent = Gemini::cachedContents()->create(
    model: 'gemini-2.5-flash',
    systemInstruction: Content::parse('You are an expert PHP developer.'),
    parts: [
        'This is a large codebase...',
        'File 1 contents...',
        'File 2 contents...'
    ],
    ttl: '3600s', // Cache for 1 hour
    displayName: 'PHP Codebase Cache'
);

echo "Cached content created: {$cachedContent->name}\n";

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::cachedContents()->list(pageSize: 10);

foreach ($response->cachedContents as $cached) {
    echo "Name: {$cached->name}\n";
    echo "Display Name: {$cached->displayName}\n";
    echo "Model: {$cached->model}\n";
    echo "Expires: {$cached->expireTime}\n";
    echo "---\n";
}

use Gemini\Laravel\Facades\Gemini;

$cached = Gemini::cachedContents()->retrieve('cachedContents/abc123');

echo "Model: {$cached->model}\n";
echo "Created: {$cached->createTime}\n";
echo "Expires: {$cached->expireTime}\n";

use Gemini\Laravel\Facades\Gemini;

// Set a new TTL, counted from now
$updated = Gemini::cachedContents()->update(
    name: 'cachedContents/abc123',
    ttl: '7200s' // Expires in 2 hours
);

// Or set absolute expiration time
$updated = Gemini::cachedContents()->update(
    name: 'cachedContents/abc123',
    expireTime: '2030-12-31T23:59:59Z'
);

use Gemini\Laravel\Facades\Gemini;

Gemini::cachedContents()->delete('cachedContents/abc123');

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::generativeModel(model: 'gemini-2.5-flash')
    ->withCachedContent('cachedContents/abc123')
    ->generateContent('Explain the main function in this codebase');

echo $response->text();

// Check token usage
echo "Cached tokens used: {$response->usageMetadata->cachedContentTokenCount}\n";
echo "Prompt tokens used (including cached tokens): {$response->usageMetadata->promptTokenCount}\n";

use Gemini\Laravel\Facades\Gemini;

$fileSearchStore = Gemini::fileSearchStores()->create(
    displayName: 'My Search Store',
);

echo "File search store created: {$fileSearchStore->name}\n"; // fileSearchStores/my-search-store-abc123

use Gemini\Laravel\Facades\Gemini;

$fileSearchStore = Gemini::fileSearchStores()->get('fileSearchStores/my-search-store');

echo "Name: {$fileSearchStore->name}\n";
echo "Display Name: {$fileSearchStore->displayName}\n";

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::fileSearchStores()->list(pageSize: 10);

foreach ($response->fileSearchStores as $fileSearchStore) {
    echo "Name: {$fileSearchStore->name}\n";
    echo "Display Name: {$fileSearchStore->displayName}\n";
    echo "--- \n";
}

use Gemini\Laravel\Facades\Gemini;

Gemini::fileSearchStores()->delete('fileSearchStores/my-search-store', force: true);

use Gemini\Enums\MimeType;
use Gemini\Laravel\Facades\Gemini;

$operation = Gemini::fileSearchStores()->upload(
    storeName: 'fileSearchStores/my-search-store',
    filename: 'document.pdf',
    mimeType: MimeType::APPLICATION_PDF,
    displayName: 'Greek Myths',
    customMetadata: [
        'author' => 'Robert Graves',
        'year' => 1955,
        'tags' => ['mythology', 'greece'],
    ],
);

echo "Upload operation: {$operation->name}\n";

use Gemini\Laravel\Facades\Gemini;

$file = Gemini::files()->upload(filename: 'document.pdf');

$operation = Gemini::fileSearchStores()->importFile(
    storeName: 'fileSearchStores/my-search-store',
    fileName: $file->name,
    customMetadata: ['author' => 'Robert Graves'],
);

use Gemini\Laravel\Facades\Gemini;

while ($operation->done === false) {
    sleep(2);
    $operation = Gemini::fileSearchStores()->getOperation($operation->name);
}

if ($operation->error !== null) {
    die('Failed: ' . json_encode($operation->error));
}

echo "Document added\n";

use Gemini\Laravel\Facades\Gemini;

$fileSearchDocument = Gemini::fileSearchStores()->getDocument('fileSearchStores/my-search-store/documents/my-document');

echo "Name: {$fileSearchDocument->name}\n";
echo "Display Name: {$fileSearchDocument->displayName}\n";
echo "State: {$fileSearchDocument->state?->value}\n";

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::fileSearchStores()->listDocuments(storeName: 'fileSearchStores/my-search-store', pageSize: 10);

foreach ($response->documents as $fileSearchDocument) {
    echo "Name: {$fileSearchDocument->name}\n";
    echo "Display Name: {$fileSearchDocument->displayName}\n";
    echo "Create Time: {$fileSearchDocument->createTime}\n";
    echo "Update Time: {$fileSearchDocument->updateTime}\n";
    echo "--- \n";
}

use Gemini\Laravel\Facades\Gemini;

Gemini::fileSearchStores()->deleteDocument('fileSearchStores/my-search-store/documents/my-document');

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::embeddingModel('gemini-embedding-001')
    ->embedContent("Write a story about a magic backpack.");

print_r($response->embedding->values);
//[
//    [0] => 0.008624583
//    [1] => -0.030451821
//    [2] => -0.042496547
//    [3] => -0.029230341
//    [4] => 0.05486475
//    [5] => 0.006694871
//    [6] => 0.004025645
//    [7] => -0.007294857
//    [8] => 0.0057651913
//    ...
//]

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::embeddingModel('gemini-embedding-001')
    ->batchEmbedContents("This is a test", "Another text");

print_r($response->embeddings);
// [
// [0] => Gemini\Data\ContentEmbedding Object
// (
//     [values] => Array
//         (
//         [0] => 0.035855837
//         [1] => -0.049537655
//         [2] => -0.06834927
//         [3] => -0.010445258
//         [4] => 0.044641383
//         [5] => 0.031156342
//         [6] => -0.007810312
//         [7] => -0.0106866965
//         ...
//         ),
// ),
// [1] => Gemini\Data\ContentEmbedding Object
// (
//     [values] => Array
//         (
//         [0] => 0.035855837
//         [1] => -0.049537655
//         [2] => -0.06834927
//         [3] => -0.010445258
//         [4] => 0.044641383
//         [5] => 0.031156342
//         [6] => -0.007810312
//         [7] => -0.0106866965
//         ...
//         ),
// ),
// ]

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::models()->list(pageSize: 3, nextPageToken: 'ChFtb2RlbHMvZ2VtaW5pLXBybw==');

$response->models;
//[
//    [0] => Gemini\Data\Model Object
//        (
//            [name] => models/gemini-2.5-flash
//            [version] => 001
//            [displayName] => Gemini 2.5 Flash
//            [description] => Stable version of Gemini 2.5 Flash
//            ...
//        )
//    [1] => Gemini\Data\Model Object
//        (
//            [name] => models/gemini-2.5-pro
//            [version] => 2.5
//            [displayName] => Gemini 2.5 Pro
//            [description] => Stable release of Gemini 2.5 Pro
//            ...
//        )
//    [2] => Gemini\Data\Model Object
//        (
//            [name] => models/gemini-embedding-001
//            [version] => 001
//            [displayName] => Gemini Embedding 001
//            [description] => Obtain a distributed representation of a text.
//            ...
//        )
//]

$response->nextPageToken; // Chltb2RlbHMvZ2VtaW5pLTEuMC1wcm8tMDAx

use Gemini\Laravel\Facades\Gemini;

$response = Gemini::models()->retrieve('models/gemini-2.5-flash');

$response->model;
//Gemini\Data\Model Object
//(
//    [name] => models/gemini-2.5-flash
//    [version] => 001
//    [displayName] => Gemini 2.5 Flash
//    [description] => Stable version of Gemini 2.5 Flash
//    [inputTokenLimit] => 1048576
//    [outputTokenLimit] => 65536
//    ...
//)

use Gemini\Exceptions\ErrorException;
use Gemini\Exceptions\TransporterException;
use Gemini\Laravel\Facades\Gemini;

try {
    $response = Gemini::generativeModel(model: 'gemini-2.5-flash')->generateContent('Hello');
} catch (ErrorException $e) {
    $e->getErrorMessage(); // The model is overloaded. Please try again later.
    $e->getErrorStatus(); // UNAVAILABLE
    $e->getErrorCode(); // 503
} catch (TransporterException $e) {
    $e->getPrevious(); // the exception thrown by the HTTP client
}

$response->promptFeedback?->blockReason; // the prompt was blocked, e.g. BlockReason::SAFETY
$response->candidates[0]->finishReason; // e.g. FinishReason::MAX_TOKENS or FinishReason::SAFETY
$response->candidates[0]->finishMessage; // more details, when available

return [
    'api_key' => env('GEMINI_API_KEY'),
    'base_url' => env('GEMINI_BASE_URL'),
    'request_timeout' => env('GEMINI_REQUEST_TIMEOUT', 60),
];

use Gemini\Laravel\Facades\Gemini;
use Gemini\Responses\GenerativeModel\GenerateContentResponse;

Gemini::fake([
    GenerateContentResponse::fake([
        'candidates' => [
            [
                'content' => [
                    'parts' => [
                        [
                            'text' => 'success',
                        ],
                    ],
                ],
            ],
        ],
    ]),
]);

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')->generateContent('test');

expect($result->text())->toBe('success');

use Gemini\Laravel\Facades\Gemini;
use Gemini\Responses\GenerativeModel\GenerateContentResponse;

Gemini::fake([
    GenerateContentResponse::fakeStream(),
]);

$result = Gemini::generativeModel(model: 'gemini-2.5-flash')->streamGenerateContent('Hello');

expect($result->getIterator()->current())
    ->text()->toBe('In the bustling city of Aethelwood, where the cobblestone streets whispered');

use Gemini\Laravel\Facades\Gemini;
use Gemini\Responses\GenerativeModel\GenerateContentResponse;

Gemini::fake([
    GenerateContentResponse::fake(),
    GenerateContentResponse::fake(),
]);

$chat = Gemini::generativeModel(model: 'gemini-2.5-flash')->startChat();
$chat->sendMessage('Hello');
$chat->sendMessage('How are you?');

Gemini::generativeModel(model: 'gemini-2.5-flash')->assertFunctionCalled(function (string $method) {
    return $method === 'startChat';
});

Gemini::generativeModel(model: 'gemini-2.5-flash')->assertSent(function (string $method, array $parameters) {
    return $method === 'generateContent' &&
        count($parameters) === 3; // Hello, the model's answer, How are you?
});

// assert list models request was sent
use Gemini\Laravel\Facades\Gemini;
use Gemini\Resources\GenerativeModel;
use Gemini\Resources\Models;

Gemini::models()->assertSent(callback: function ($method) {
    return $method === 'list';
});
// or
Gemini::assertSent(resource: Models::class, callback: function ($method) {
    return $method === 'list';
});

Gemini::generativeModel(model: 'gemini-2.5-flash')->assertSent(function (string $method, array $parameters) {
    return $method === 'generateContent' &&
        $parameters[0] === 'Hello';
});
// or
Gemini::assertSent(resource: GenerativeModel::class, model: 'gemini-2.5-flash', callback: function (string $method, array $parameters) {
    return $method === 'generateContent' &&
        $parameters[0] === 'Hello';
});

// assert 2 generative model requests were sent
Gemini::assertSent(resource: GenerativeModel::class, model: 'gemini-2.5-flash', callback: 2);
// or
Gemini::generativeModel(model: 'gemini-2.5-flash')->assertSent(2);

// assert no generative model requests were sent
Gemini::assertNotSent(resource: GenerativeModel::class, model: 'gemini-2.5-flash');
// or
Gemini::generativeModel(model: 'gemini-2.5-flash')->assertNotSent();

// assert no requests were sent
Gemini::assertNothingSent();

use Gemini\Data\GenerationConfig;
use Gemini\Laravel\Facades\Gemini;

Gemini::generativeModel(model: 'gemini-2.5-flash')->assertFunctionCalled(function (string $method, array $parameters) {
    return $method === 'withGenerationConfig' &&
        $parameters[0] instanceof GenerationConfig;
});

use Gemini\Exceptions\ErrorException;
use Gemini\Laravel\Facades\Gemini;

Gemini::fake([
    new ErrorException([
        'message' => 'The model `gemini-basic` does not exist',
        'status' => 'INVALID_ARGUMENT',
        'code' => 400,
    ]),
]);

// the `ErrorException` will be thrown
Gemini::generativeModel(model: 'gemini-2.5-flash')->generateContent('test');

bash
composer 

bash
php artisan gemini:install

bash
composer