Gemini PHP for Laravel

Enable the model to call custom functions by defining them as Tool objects containing FunctionDeclarations.

1. Define the function's name, description, and parameters using a Schema.
2. Attach the tool to the model using withTool().
3. When the model returns a functionCall in a response part, execute your local logic and send the result back to the model using sendMessage() with a Content object containing a FunctionResponse.

// 1. Define the tool
$tool = new Tool(functionDeclarations: [
    new FunctionDeclaration(
        name: 'addition',
        description: 'Performs addition',
        parameters: new Schema(
            type: DataType::OBJECT,
            properties: [
                'number1' => new Schema(type: DataType::NUMBER),
                'number2' => new Schema(type: DataType::NUMBER),
            ],
            required: ['number1', 'number2']
        )
    )
]);

// 2. Start chat with tool
$chat = Gemini::generativeModel(model: 'gemini-2.0-flash')->withTool($tool)->startChat();
$response = $chat->sendMessage('What is 4 + 3?');

// 3. Handle the call
if ($response->parts()[0]->functionCall !== null) {
    $call = $response->parts()[0]->functionCall;
    // ... execute local logic ...
    $functionResponse = new Content(
        parts: [new Part(functionResponse: new FunctionResponse('addition', ['answer' => 7]))],
        role: Role::USER
    );
    $response = $chat->sendMessage($functionResponse);
}

The File API allows you to upload and manage files (up to 2GB per file, 20GB total per project) for use in prompts. Files are stored for 48 hours.

• Upload: Use Gemini::files()->upload() with a filename and MIME type. Note that uploads are asynchronous; you must poll metadataGet() until the state is complete().
• List: Use Gemini::files()->list() to see all files.
• Metadata: Use Gemini::files()->metadataGet() to retrieve details about a specific file.
• Delete: Use Gemini::files()->delete() to remove a file.

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

// Upload and poll for completion
$files = Gemini::files();
$meta = $files->upload(filename: 'video.mp4', mimeType: MimeType::VIDEO_MP4, displayName: 'Video');

do {
    sleep(2);
    $meta = $files->metadataGet($meta->uri);
} while (!$meta->state->complete());

if ($meta->state == FileState::Failed) {
    // Handle error
}

Context caching reduces costs and latency for large, frequently used inputs.

• Create: Use Gemini::cachedContents()->create() with a ttl (e.g., '3600s') or an absolute expireTime.
• List/Retrieve: Use list() or retrieve() to manage existing caches.
• Update: Use update() to extend the TTL or change the expiration time.
• Use: Pass the cache name to withCachedContent() when initializing a generative model.
• Delete: Use delete() to remove a cache.

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

// Create cache
$cachedContent = Gemini::cachedContents()->create(
    model: 'gemini-2.0-flash',
    systemInstruction: Content::parse('You are an expert PHP developer.'),
    parts: ['Large codebase content...'],
    ttl: '3600s'
);

// Use cache
$response = Gemini::generativeModel(model: 'gemini-2.0-flash')
    ->withCachedContent($cachedContent->name)
    ->generateContent('Explain the main function.');

Constrain the model to return JSON by configuring GenerationConfig with responseMimeType: ResponseMimeType::APPLICATION_JSON and providing a Schema. This allows you to define the expected structure (types, properties, and required fields). Use $result->json() to retrieve the parsed data.

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.0-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)
                    ,
                    required: ['recipe_name', 'cooking_time_in_minutes'],
                )
            )
        )
    )
    ->generateContent('List 5 popular cookie recipes with cooking time');

$data = $result->json();