Vertex AI support

[koveitan]

Can I use Google Cloud Vertex AI (e.g., Gemini 2.5 / embeddings / etc.) as the model provider with Prism? If yes, is there a recommended way to configure authentication and URL?

[GregoireGaonach]

I have the same question ⬆️

[ChrisB-TL]

I did look at this a while ago, but they don't support auth keys so it's not entirely straight forward. I'm not sure if that has changed since, though.

[GregoireGaonach]

Thanks for your reply!

[koveitan]

I think it's really important to add this capability since Vertex AI has production-grade rate limits, while the Gemini API has significant limits.

[marcel-domke-scayle]

I think it's really important to add this capability since Vertex AI has production-grade rate limits, while the Gemini API has significant limits.
Was the vertex AI support already implemented? How did you solve it?

[TonsiTT]

Would love to see Vertex AI support as well

[sca1235]

Agreed Vertex is better for security options plus rate limits. Did a pass to see what it takes. Below is AI so not verified.

---

To add Vertex AI support to the prism-php/prism package, you need to create a new Provider. While Vertex AI and Google AI Studio (Gemini) use the same underlying models, they differ significantly in authentication (OAuth/IAM vs. API Key) and API Endpoint URLs.

Here is the step-by-step guide to implementing the Vertex provider.

Prerequisites

Vertex AI requires Google Cloud authentication. You will likely need the Google Auth library to generate Bearer tokens.

composer require google/auth

Step 1: Create the Directory Structure

Create a new directory alongside Gemini:
src/Providers/Vertex

Step 2: Create the Vertex Provider Class

Create src/Providers/Vertex/Vertex.php.

Unlike the Gemini provider which takes an API key, this provider needs a projectId and location (region). It must also generate an auth token.

<?php

declare(strict_types=1);

namespace Prism\Prism\Providers\Vertex;

use Google\Auth\ApplicationDefaultCredentials;
use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use Prism\Prism\Providers\Provider;
use Prism\Prism\Providers\Gemini\Maps\ToolMap;
use Prism\Prism\Providers\Gemini\Maps\SchemaMap;
use Prism\Prism\Providers\Gemini\Handlers\Structured;
use Prism\Prism\Providers\Gemini\Handlers\Text;

class Vertex extends Provider
{
    protected string $projectId;
    protected string $location;

    public function __construct(string $projectId, string $location = 'us-central1')
    {
        $this->projectId = $projectId;
        $this->location = $location;
    }

    protected function client(): Client
    {
        // Fetch Google Cloud Credentials (ADC)
        $scopes = ['https://www.googleapis.com/auth/cloud-platform'];
        $middleware = ApplicationDefaultCredentials::getMiddleware($scopes);
        $stack = HandlerStack::create();
        $stack->push($middleware);

        return new Client([
            'handler' => $stack,
            'base_uri' => sprintf(
                'https://%s-aiplatform.googleapis.com/v1/projects/%s/locations/%s/publishers/google/models/',
                $this->location,
                $this->projectId,
                $this->location
            ),
            'headers' => [
                'Content-Type' => 'application/json',
            ],
        ]);
    }

    // Vertex reuses the exact same payload structure as Gemini,
    // so we can reuse the Gemini Mappers and Handlers.
    // If Prism is strict about namespaces, you may need to subclass them,
    // but usually, you can import them directly as shown below.

    public function text(): Text
    {
        return new Text($this->client());
    }

    public function structured(): Structured
    {
        return new Structured($this->client());
    }
    
    // You will need to implement the other interface methods required by Provider
    // copying the logic from src/Providers/Gemini/Gemini.php but keeping
    // the client configuration above.
}

Step 3: Handle the API Endpoint Differences

The standard Gemini API uses generativelanguage.googleapis.com. Vertex uses aiplatform.googleapis.com.

In the code above, the base_uri is set to the Vertex format:
https://{location}-aiplatform.googleapis.com/v1/projects/{project}/locations/{location}/publishers/google/models/

When the handlers (like Text or Structured) make a request to :generateContent, it will append to this base URL.

Step 4: Reusing Maps and Handlers

Since the JSON body for Vertex and Gemini Studio is 99% identical, you do not need to rewrite ToolMap.php, SchemaMap.php, or the Handler classes.

1. Open src/Providers/Vertex/Vertex.php.
2. Import the Gemini handlers at the top:

   use Prism\Prism\Providers\Gemini\Handlers\Text;
   use Prism\Prism\Providers\Gemini\Handlers\Structured;
   // etc...

3. Instantiate them passing your Vertex-configured $this->client().

Note: If the existing Gemini handlers act oddly because of the URL structure, you may need to copy the Handlers folder from Gemini to Vertex and remove the base URL logic from inside them, ensuring they rely solely on the Guzzle client's base_uri.

Step 5: Registering/Using the Provider

You can now use the provider in your application code:

use Prism\Prism\Prism;
use Prism\Prism\Providers\Vertex\Vertex;

$prism = new Prism();

$response = $prism->text()
    ->using(new Vertex(projectId: 'my-gcp-project', location: 'us-central1'))
    ->withModel('gemini-1.5-pro')
    ->withPrompt('Hello Vertex AI!')
    ->generate();

echo $response->text;

Summary of Changes Required

1. Dependency: Add google/auth to composer.json.
2. New Class: Create Vertex.php extending Provider.
3. Auth: Implement ApplicationDefaultCredentials middleware in the Guzzle client.
4. Base URL: Point to aiplatform.googleapis.com.
5. Reuse: Import and return existing Gemini Handlers (Text, Structured, etc.) from your new Vertex class.

[sixlive]

So I might be open to this but I think it would need to be a separate package like bedrock due to the auth library dependency, I try and keep Prism light on dependencies. I don't know when I'll have bandwidth to tackle this for a minute but I'd be open to pitching in on some PRs if someone can drive it and keep the code 'Prism idiomatic'

[RanaMoizHaider]

Hi everyone! 👋

Following up on @sixlive's suggestion to build this as a standalone package, I'm excited to share that I just released v1.0.0 of rmh/vertex!

This package adds Google Vertex AI support to Prism, allowing you to use Gemini models directly via Google Cloud. I've strictly followed Prism's idiomatic architecture and approaches (similar to the Bedrock package) to make sure it feels like a native integration.

You can install it right now:

composer require rmh/vertex

You can check out the source code and documentation here:
👉 github.com/RanaMoizHaider/vertex

I've tested it thoroughly with Gemini models, but Vertex supports other providers as well. I'd love for you all to take it for a spin. If you run into any errors or have feedback, please open an issue on the repository.

Happy building! 🚀

[GregoireGaonach]

Thanks a lot @RanaMoizHaider 🙏

[koveitan]

Awesome work @RanaMoizHaider

[sca1235]

Nice job. Does it work with ADC? Credentials from an attached service account (for code running on Google Cloud Platform). Instead of hardcoded json. https://github.com/googleapis/google-cloud-php/blob/main/AUTHENTICATION.md

[RanaMoizHaider]

Hey @sca1235! Yes, ADC is now supported as of the latest release (v1.1.0). The package uses ApplicationDefaultCredentials under the hood, so if your code is running on Google Cloud (GCE, GKE, Cloud Run, etc.) with a service account attached, it will pick up the credentials automatically. Give it a try and let me know if you run into anything!

[tayeke]

I need Vertex AI support so I can support HIPAA compliance needs in google cloud.