ADK Vertex AI Mentions Audit — All Languages

Date: 2026-03-30

Repos audited: adk-python, adk-go, adk-java, adk-js, adk-docs

Method: grep -rni 'vertex' across all source/doc files

Summary Table

Repo	P0 (Raw API)	P1 (SDK)	P2 (Config)	P3 (Docs)	Total
adk-python	0	1026	0	397	1423
adk-go	0	108	0	55	163
adk-java	0	261	0	91	352
adk-js	0	85	0	64	149
adk-docs	4	190	1	286	481
TOTAL	4	1670	1	893	2568

P0 — Raw API Endpoint Requests

Direct HTTP/REST calls to Vertex AI endpoints

adk-docs (4 matches)

./docs/agents/models/google-gemini.md:124 — Pre-requisites: A Google Cloud Project with Vertex AI enabled.
./docs/deploy/agent-engine/deploy.md:60 — * To use Agent Engine, you need to enable the Vertex AI API. Click on the "Enable" button to enable the API. Once enabled, it
./docs/get-started/quickstart.md:334 — 1. Set up a Google Cloud project and [enable the Vertex AI API](https://console.cloud.google.
./docs/get-started/streaming/quickstart-streaming.md:109 — * Enable the Vertex AI API.

P1 — SDK Usage

Code using Vertex AI SDKs, classes, and service instantiation

adk-python (1026 matches)

./.github/workflows/analyze-releases-for-adk-docs-updates.yml:61 — GOOGLE_GENAI_USE_VERTEXAI: 0
./.github/workflows/discussion_answering.yml:42 — VERTEXAI_DATASTORE_ID: ${{ secrets.VERTEXAI_DATASTORE_ID }}
./.github/workflows/discussion_answering.yml:44 — GOOGLE_GENAI_USE_VERTEXAI: 1
./.github/workflows/pr-triage.yml:39 — GOOGLE_GENAI_USE_VERTEXAI: 0
./.github/workflows/triage.yml:45 — GOOGLE_GENAI_USE_VERTEXAI: 0
./.github/workflows/upload-adk-docs-to-vertex-ai-search.yml:46 — VERTEXAI_DATASTORE_ID: ${{ secrets.VERTEXAI_DATASTORE_ID }}
./.github/workflows/upload-adk-docs-to-vertex-ai-search.yml:47 — GOOGLE_GENAI_USE_VERTEXAI: 1
./.github/workflows/upload-adk-docs-to-vertex-ai-search.yml:52 — run: python -m adk_answering_agent.upload_docs_to_vertex_ai_search
./CHANGELOG.md:320 — * Use async iteration for VertexAiSessionService.list_sessions pagination (758d337)
./CHANGELOG.md:330 — * Migrate VertexAiMemoryBankService to use the async Vertex AI client (64a44c2)
./CHANGELOG.md:379 — * Support dynamic configuration for VertexAiSearchTool (585ebfd)
./CHANGELOG.md:758 — * Add vertexai initialization for code being deployed to AgentEngine (b8e4aed)
./CHANGELOG.md:769 — * Fix Use async for to loop through event iterator to get all events in vertex_ai_session_service (9211f4c)
./CHANGELOG.md:851 — * Make VertexAiSessionService fully asynchronous (f7e2a7a)
./CHANGELOG.md:908 — * Add sample agent for VertexAiCodeExecutor (edfe553)
./CHANGELOG.md:933 — * Allow passing extra kwargs to create_session of VertexAiSessionService (6a5eac0)
./CHANGELOG.md:942 — * Add bypass_multi_tools_limit option to GoogleSearchTool and VertexAiSearchTool (9a6b850, [6da7274](https://g
./CHANGELOG.md:982 — * Set default for bypass_multi_tools_limit to False for GoogleSearchTool and VertexAiSearchTool (6da7274)
./CHANGELOG.md:1018 — * Support using VertexAiSearchTool built-in tool with other tools in the same agent (4485379)
./CHANGELOG.md:1046 — * Fix VertexAiSessionService base_url override to preserve initialized http_options (8110e41, [c51ea0b](https://
./CHANGELOG.md:1051 — * Migrate VertexAiSessionService to use Agent Engine SDK (90d4c19)
./CHANGELOG.md:1052 — * Migrate VertexAiMemoryBankService to use Agent Engine SDK (d1efc84, [97b950b](https://github.com/google/adk-py
./CHANGELOG.md:1150 — * Fix pagination of list_sessions in VertexAiSessionService e63fe0c
./CHANGELOG.md:1248 — * Lazy load VertexAiCodeExecutor and ContainerCodeExecutor (018db79)
./CHANGELOG.md:1494 — * Add custom_metadata to VertexAiSessionService when adding events a021222
./CHANGELOG.md:1546 — * Add implementation of VertexAiMemoryBankService and support in FastAPI endpoint (abc89d2)
./CHANGELOG.md:1549 — * Add Vertex Express mode compatibility for VertexAiSessionService (00cc8cd)
./CHANGELOG.md:1580 — * This fixes the broken VertexAiSessionService
./CHANGELOG.md:1614 — * Set agent_engine_id in the VertexAiSessionService constructor, also use the agent_engine_id field instead of overriding app_name in FastAPI endpoint ([fc65873](https://github.com/google/adk-py
./CHANGELOG.md:1676 — * Expose more config of VertexAiSearchTool from latest Google GenAI SDK (2b5c89b)
./contributing/samples/adk_answering_agent/README.md:70 — The upload_docs_to_vertex_ai_search.py is a script to upload ADK related docs to Vertex AI Search datastore to update the knowledge base. It can be executed with the following command in your termin
./contributing/samples/adk_answering_agent/README.md:74 — python -m adk_answering_agent.upload_docs_to_vertex_ai_search
./contributing/samples/adk_answering_agent/README.md:105 — * GOOGLE_GENAI_USE_VERTEXAI=TRUE: (Required) Use Google Vertex AI for the authentication.
./contributing/samples/adk_answering_agent/README.md:108 — * VERTEXAI_DATASTORE_ID=YOUR_DATASTORE_ID: (Required) The full Vertex AI datastore ID for the document store (i.e. knowledge base), with the format of `projects/{project_number}/locations/{locat
./contributing/samples/adk_answering_agent/agent.py:20 — from adk_answering_agent.settings import VERTEXAI_DATASTORE_ID
./contributing/samples/adk_answering_agent/agent.py:27 — from google.adk.tools.vertex_ai_search_tool import VertexAiSearchTool
./contributing/samples/adk_answering_agent/agent.py:47 — using the VertexAiSearchTool.
./contributing/samples/adk_answering_agent/agent.py:72 — * Use the VertexAiSearchTool to find relevant information before answering.
./contributing/samples/adk_answering_agent/agent.py:111 — VertexAiSearchTool(data_store_id=VERTEXAI_DATASTORE_ID),
./contributing/samples/adk_answering_agent/settings.py:28 — VERTEXAI_DATASTORE_ID = os.getenv("VERTEXAI_DATASTORE_ID")
./contributing/samples/adk_answering_agent/settings.py:29 — if not VERTEXAI_DATASTORE_ID:
./contributing/samples/adk_answering_agent/settings.py:30 — raise ValueError("VERTEXAI_DATASTORE_ID environment variable not set")
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:22 — from adk_answering_agent.settings import VERTEXAI_DATASTORE_ID
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:87 — # Vertex AI search doesn't recognize text/markdown,
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:103 — # Vertex AI search doesn't recognize yaml,
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:137 — def import_from_gcs_to_vertex_ai(
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:141 — """Triggers a bulk import task from a GCS folder to Vertex AI Search."""
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:183 — if not VERTEXAI_DATASTORE_ID:
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:185 — "[ERROR] VERTEXAI_DATASTORE_ID environment variable not set."
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:221 — # 3. Import the docs from GCS to Vertex AI Search.
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:222 — if not import_from_gcs_to_vertex_ai(VERTEXAI_DATASTORE_ID, GCS_BUCKET_NAME):
./contributing/samples/adk_answering_agent/upload_docs_to_vertex_ai_search.py:224 — "[ERROR] Failed to import docs from GCS to Vertex AI Search."
./contributing/samples/adk_knowledge_agent/README.md:18 — export GOOGLE_GENAI_USE_VERTEXAI=True
./contributing/samples/adk_knowledge_agent/agent.py:21 — from google.adk.tools.vertex_ai_search_tool import VertexAiSearchTool
./contributing/samples/adk_knowledge_agent/agent.py:24 — VERTEXAI_DATASTORE_ID = "projects/adk-agent-builder-assistant/locations/global/collections/default_collection/dataStores/adk-agent-builder-sample-datastore_1758230446136"
./contributing/samples/adk_knowledge_agent/agent.py:69 — You can use the VertexAiSearchTool to search for ADK examples and documentation in the document store.
./contributing/samples/adk_knowledge_agent/agent.py:72 — tools=[VertexAiSearchTool(data_store_id=VERTEXAI_DATASTORE_ID)],
./contributing/samples/bigquery/README.md:70 — * GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contributing/samples/bigquery_mcp/README.md:44 — * GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contributing/samples/bigtable/README.md:37 — * GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contributing/samples/built_in_multi_tools/README.md:2 — VertexAiSearchTool can be used together with other tools, even though the model
./contributing/samples/built_in_multi_tools/README.md:7 — To run this agent, set the environment variable VERTEXAI_DATASTORE_ID
./contributing/samples/built_in_multi_tools/agent.py:22 — from google.adk.tools.vertex_ai_search_tool import VertexAiSearchTool
./contributing/samples/built_in_multi_tools/agent.py:26 — VERTEXAI_DATASTORE_ID = os.getenv("VERTEXAI_DATASTORE_ID")
./contributing/samples/built_in_multi_tools/agent.py:27 — if not VERTEXAI_DATASTORE_ID:
./contributing/samples/built_in_multi_tools/agent.py:28 — raise ValueError("VERTEXAI_DATASTORE_ID environment variable not set")
./contributing/samples/built_in_multi_tools/agent.py:55 — - Use VertexAISearchTool to search for Google Agent Development Kit (ADK) information in the datastore.
./contributing/samples/built_in_multi_tools/agent.py:60 — VertexAiSearchTool(
./contributing/samples/built_in_multi_tools/agent.py:61 — data_store_id=VERTEXAI_DATASTORE_ID, bypass_multi_tools_limit=True
./contributing/samples/custom_code_execution/README.md:6 — subclassing VertexAiCodeExecutor.
./contributing/samples/custom_code_execution/README.md:19 — executor (e.g., VertexAiCodeExecutor) and overriding its execute_code
./contributing/samples/custom_code_execution/README.md:32 — It achieves this by: 1. Subclassing VertexAiCodeExecutor: It inherits all
./contributing/samples/custom_code_execution/agent.py:28 — from google.adk.code_executors.vertex_ai_code_executor import VertexAiCodeExecutor
./contributing/samples/custom_code_execution/agent.py:61 — class CustomCodeExecutor(VertexAiCodeExecutor):
./contributing/samples/files_retrieval_agent/README.md:40 — export GOOGLE_GENAI_USE_VERTEXAI=1
./contributing/samples/gepa/experiment.py:267 — agent_model_provider: str = 'vertex_ai',
./contributing/samples/gepa/experiment.py:269 — user_model_provider: str = 'vertex_ai',
./contributing/samples/gepa/run_experiment.py:118 — agent_model_provider='vertex_ai',
./contributing/samples/gepa/run_experiment.py:120 — user_model_provider='vertex_ai',
./contributing/samples/gepa/utils.py:40 — """Returns an inference function on VertexAI based on provided model."""
./contributing/samples/hello_world_apigeellm/README.md:47 — - provider (optional): Can be vertex_ai or gemini.
./contributing/samples/hello_world_apigeellm/README.md:49 — - If omitted, the provider is determined by the GOOGLE_GENAI_USE_VERTEXAI environment variable. If this variable is set to true or 1, Vertex AI is used; otherwise, gemini is used by default.
./contributing/samples/hello_world_apigeellm/README.md:64 — - Provider is Vertex AI if GOOGLE_GENAI_USE_VERTEXAI is true; otherwise, Gemini.
./contributing/samples/hello_world_apigeellm/README.md:72 — - model="apigee/vertex_ai/gemini-2.5-flash"
./contributing/samples/hello_world_apigeellm/README.md:81 — - model="apigee/vertex_ai/v1beta/gemini-2.5-flash"
./contributing/samples/hello_world_litellm/agent.py:64 — # model=LiteLlm(model="vertex_ai/gemini-2.5-pro-exp-03-25"),
./contributing/samples/hello_world_litellm/agent.py:65 — # model=LiteLlm(model="vertex_ai/claude-3-5-haiku"),
./contributing/samples/hello_world_litellm_add_function_to_prompt/agent.py:59 — model="vertex_ai/meta/llama-4-maverick-17b-128e-instruct-maas",
./contributing/samples/live_bidi_streaming_tools_agent/agent.py:60 — client = Client(vertexai=False)
./contributing/samples/oauth2_client_credentials/README.md:85 — GOOGLE_GENAI_USE_VERTEXAI=1
./contributing/samples/postgres_session_service/README.md:140 — GOOGLE_GENAI_USE_VERTEXAI=true
./contributing/samples/postgres_session_service/README.md:149 — export GOOGLE_GENAI_USE_VERTEXAI=true
./contributing/samples/pubsub/README.md:29 — * GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contributing/samples/rag_agent/agent.py:19 — from google.adk.tools.retrieval.vertex_ai_rag_retrieval import VertexAiRagRetrieval
./contributing/samples/rag_agent/agent.py:20 — from vertexai.preview import rag
./contributing/samples/rag_agent/agent.py:24 — ask_vertex_retrieval = VertexAiRagRetrieval(
./contributing/samples/spanner/README.md:41 — * GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contributing/samples/spanner_admin/README.md:45 — * GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contributing/samples/spanner_rag_agent/README.md:53 — Next, you will create an Embedding model in Spanner and configure it to VertexAI
./contributing/samples/spanner_rag_agent/README.md:119 — * GOOGLE_GENAI_USE_VERTEXAI=FALSE

adk-go (108 matches)

./examples/vertexai/agent.go:29 — "google.golang.org/adk/session/vertexai"
./examples/vertexai/agent.go:49 — engineID := os.Getenv("VERTEX_ENGINE_ID")
./examples/vertexai/agent.go:51 — log.Fatalf("Env var VERTEX_ENGINE_ID is not set")
./examples/vertexai/agent.go:58 — srvs, err := vertexai.NewSessionService(ctx, vertexai.VertexAIServiceConfig{
./examples/vertexai/imagegenerator/main.go:16 — // using Vertex AI's Imagen model, save them as artifacts, and then save them
./examples/vertexai/imagegenerator/main.go:93 — // This is a function tool to generate images using Vertex AI's Imagen model.
./examples/vertexai/imagegenerator/main.go:98 — Backend: genai.BackendVertexAI,
./examples/vertexai/vertexengine/create_engine.go:28 — // main defines an example of how to initialize a vertex ai reasoning engine
./examples/web/agents/image_generator.go:37 — Backend: genai.BackendVertexAI,
./internal/llminternal/base_flow_telemetry_test.go:150 — if val := attrs["gcp.vertexai.invocation_id"]; val != "" {
./internal/llminternal/googlellm/variant.go:29 — // GetGoogleLLMVariant returns the Google LLM variant used (GeminiAPI or VertexAI).
./internal/llminternal/googlellm/variant_test.go:76 — {"Gemini2.0_Vertex", "gemini-2.0-flash", genai.BackendVertexAI, false},
./internal/llminternal/googlellm/variant_test.go:78 — {"NonGemini_Vertex", "not-a-gemini", genai.BackendVertexAI, false},
./internal/llminternal/googlellm/variant_test.go:80 — {"Gemini3.0_Vertex", "gemini-3.0", genai.BackendVertexAI, false},
./internal/llminternal/outputschema_processor_test.go:169 — variant: func() *genai.Backend { x := genai.BackendVertexAI; return &x }(),
./internal/telemetry/logger.go:136 — if variant == genai.BackendVertexAI {
./internal/telemetry/logger.go:137 — val := log.KeyValueFromAttribute(semconv.GenAISystemGCPVertexAI)
./internal/telemetry/logger_test.go:166 — backend: genai.BackendVertexAI,
./internal/telemetry/logger_test.go:178 — log.KeyValueFromAttribute(semconv.GenAISystemGCPVertexAI),
./internal/telemetry/logger_test.go:395 — backend: genai.BackendVertexAI,
./internal/telemetry/logger_test.go:419 — log.KeyValueFromAttribute(semconv.GenAISystemGCPVertexAI),
./internal/telemetry/logger_test.go:564 — LogRequest(ctx, req, genai.BackendVertexAI)
./internal/telemetry/logger_test.go:565 — LogResponse(ctx, &model.LLMResponse{}, genai.BackendVertexAI)
./model/apigee/apigee.go:34 — googleGenaiUseVertexAIEnvVar = "GOOGLE_GENAI_USE_VERTEXAI"
./model/apigee/apigee.go:42 — isVertexAI bool
./model/apigee/apigee.go:107 — backendType := backendType(mi.isVertexAI)
./model/apigee/apigee.go:109 — clientConfig, err := generateClientConfig(mi.isVertexAI, backendType, httpOptions, cfg.HTTPClient)
./model/apigee/apigee.go:145 — info.isVertexAI = !strings.HasPrefix(modelName, "apigee/gemini/") &&
./model/apigee/apigee.go:146 — (strings.HasPrefix(modelName, "apigee/vertex_ai/") ||
./model/apigee/apigee.go:147 — isEnabled(googleGenaiUseVertexAIEnvVar))
./model/apigee/apigee.go:154 — if components[0] == "vertex_ai" || components[0] == "gemini" {
./model/apigee/apigee.go:163 — if (components[0] == "vertex_ai" || components[0] == "gemini") && strings.HasPrefix(components[1], "v") {
./model/apigee/apigee.go:200 — func backendType(isVertexAI bool) genai.Backend {
./model/apigee/apigee.go:201 — if isVertexAI {
./model/apigee/apigee.go:202 — return genai.BackendVertexAI
./model/apigee/apigee.go:213 — func generateClientConfig(isVertexAI bool, backendType genai.Backend, httpOptions *genai.HTTPOptions, httpClient *http.Client) (*genai.ClientConfig, error) {
./model/apigee/apigee.go:221 — if isVertexAI {
./model/apigee/apigee_test.go:53 — "apigee/vertex_ai/gemini-1.5-flash",
./model/apigee/apigee_test.go:55 — "apigee/vertex_ai/v1beta/gemini-1.5-flash",
./model/apigee/apigee_test.go:61 — if strings.Contains(modelName, "vertex_ai") {
./model/apigee/apigee_test.go:101 — "apigee/vertex_ai/v1/model/extra",
./model/apigee/apigee_test.go:128 — want: &modelInfo{modelID: "gemini-1.5-flash", apiVersion: "", isVertexAI: false},
./model/apigee/apigee_test.go:134 — want: &modelInfo{modelID: "gemini-1.5-flash", apiVersion: "", isVertexAI: true},
./model/apigee/apigee_test.go:140 — want: &modelInfo{modelID: "gemini-1.5-flash", apiVersion: "v1", isVertexAI: false},
./model/apigee/apigee_test.go:144 — modelName: "apigee/vertex_ai/gemini-1.5-flash",
./model/apigee/apigee_test.go:146 — want: &modelInfo{modelID: "gemini-1.5-flash", apiVersion: "", isVertexAI: true},
./model/apigee/apigee_test.go:152 — want: &modelInfo{modelID: "gemini-1.5-flash", apiVersion: "v1", isVertexAI: false},
./model/apigee/apigee_test.go:156 — modelName: "apigee/vertex_ai/v1beta/gemini-1.5-flash",
./model/apigee/apigee_test.go:158 — want: &modelInfo{modelID: "gemini-1.5-flash", apiVersion: "v1beta", isVertexAI: true},
./model/apigee/apigee_test.go:172 — modelName: "apigee/vertex_ai/v1/model/extra",
./model/apigee/apigee_test.go:185 — t.Setenv(googleGenaiUseVertexAIEnvVar, tc.vertexEnv)
./model/apigee/apigee_test.go:187 — if err := os.Unsetenv(googleGenaiUseVertexAIEnvVar); err != nil {
./model/apigee/apigee_test.go:188 — t.Errorf("failed to unset %s: %v", googleGenaiUseVertexAIEnvVar, err)
./model/apigee/apigee_test.go:237 — t.Setenv(googleGenaiUseVertexAIEnvVar, "true")
./model/apigee/apigee_test.go:260 — t.Setenv(googleGenaiUseVertexAIEnvVar, "true")
./model/gemini/gemini_test.go:148 — t.Setenv("GOOGLE_GENAI_USE_VERTEXAI", strconv.FormatBool(tt.useVertex))
./session/vertexai/service_test.go:15 — package vertexai
./session/vertexai/service_test.go:47 — func Test_vertexaiService_Create(t *testing.T) {
./session/vertexai/service_test.go:68 — errMessage: "user-provided Session id is not supported for VertexAISessionService: "testSessionID"",
./session/vertexai/service_test.go:77 — // TODO had to parse to float64, sending int was modified by vertex or by vertex client, int should work
./session/vertexai/service_test.go:94 — errMessage: "user-provided Session id is not supported for VertexAISessionService: "session1"",
./session/vertexai/service_test.go:106 — t.Fatalf("vertexAiService.Create() error = %v, wantErr %v", err, tt.errMessage)
./session/vertexai/service_test.go:138 — func Test_vertexaiService_Get(t *testing.T) {
./session/vertexai/service_test.go:425 — t.Fatalf("vertexAiService.Get() error = %v, wantErr %v", err, tt.wantErr)
./session/vertexai/service_test.go:454 — func Test_vertexaiService_List(t *testing.T) {
./session/vertexai/service_test.go:539 — t.Errorf("vertexAiService.List() error = %v, wantErr %v", err, tt.wantErr)
./session/vertexai/service_test.go:558 — t.Errorf("vertexAiService.List() = %v (-want +got):\n%s", got, diff)
./session/vertexai/service_test.go:565 — func Test_vertexaiService_AppendEvent(t *testing.T) {
./session/vertexai/service_test.go:900 — t.Errorf("vertexAiService.AppendEvent() error = %v, wantErr %v", err, tt.wantErr)
./session/vertexai/service_test.go:913 — t.Fatalf("vertexAiService.Get() error = %v, wantErr %v", err, tt.wantErr)
./session/vertexai/service_test.go:941 — func Test_vertexaiService_StateManagement(t *testing.T) {
./session/vertexai/service_test.go:1121 — v, err := NewSessionService(t.Context(), VertexAIServiceConfig{
./session/vertexai/session.go:15 — package vertexai
./session/vertexai/vertexai.go:15 — package vertexai
./session/vertexai/vertexai.go:27 — // VertexAiSessionService
./session/vertexai/vertexai.go:28 — type vertexAiService struct {
./session/vertexai/vertexai.go:29 — client *vertexAiClient
./session/vertexai/vertexai.go:32 — type VertexAIServiceConfig struct {
./session/vertexai/vertexai.go:33 — // ProjectID with VertexAI API enabled.
./session/vertexai/vertexai.go:40 — // For example, a reasoningEngine can be created via the Vertex AI REST
./session/vertexai/vertexai.go:45 — // NewSessionService returns VertextAiSessionService implementation.
./session/vertexai/vertexai.go:46 — func NewSessionService(ctx context.Context, cfg VertexAIServiceConfig, opts ...option.ClientOption) (session.Service, error) {
./session/vertexai/vertexai.go:47 — client, err := newVertexAiClient(ctx, cfg.Location, cfg.ProjectID, cfg.ReasoningEngine, opts...)
./session/vertexai/vertexai.go:49 — return nil, fmt.Errorf("failed to create Vertex AI client: %w", err)
./session/vertexai/vertexai.go:52 — return &vertexAiService{client: client}, nil
./session/vertexai/vertexai.go:55 — func (s *vertexAiService) Create(ctx context.Context, req *session.CreateRequest) (*session.CreateResponse, error) {
./session/vertexai/vertexai.go:60 — return nil, fmt.Errorf("user-provided Session id is not supported for VertexAISessionService: %q", req.SessionID)
./session/vertexai/vertexai.go:69 — func (s *vertexAiService) Get(ctx context.Context, req *session.GetRequest) (*session.GetResponse, error) {
./session/vertexai/vertexai.go:107 — func (s *vertexAiService) List(ctx context.Context, req *session.ListRequest) (*session.ListResponse, error) {
./session/vertexai/vertexai.go:118 — func (s *vertexAiService) Delete(ctx context.Context, req *session.DeleteRequest) error {
./session/vertexai/vertexai.go:129 — func (s *vertexAiService) AppendEvent(ctx context.Context, sess session.Session, event *session.Event) error {
./session/vertexai/vertexai.go:139 — return fmt.Errorf("AppendEvent for Vertex AI service only supports sessions created by it, got %T", sess)
./session/vertexai/vertexai_client.go:15 — package vertexai
./session/vertexai/vertexai_client.go:45 — type vertexAiClient struct {
./session/vertexai/vertexai_client.go:52 — func newVertexAiClient(ctx context.Context, location, projectID, reasoningEngine string, opts ...option.ClientOption) (*vertexAiClient, error) {
./session/vertexai/vertexai_client.go:57 — return &vertexAiClient{location, projectID, reasoningEngine, rpcClient}, nil
./session/vertexai/vertexai_client.go:61 — func (c *vertexAiClient) Close() error {
./session/vertexai/vertexai_client.go:65 — func (c *vertexAiClient) createSession(ctx context.Context, req *session.CreateRequest) (*localSession, error) {
./session/vertexai/vertexai_client.go:110 — func (c *vertexAiClient) waitForOperation(ctx context.Context, appName, userId, sessionID string) (*localSession, error) {
./session/vertexai/vertexai_client.go:135 — func (c *vertexAiClient) getSession(ctx context.Context, req *session.GetRequest) (*localSession, error) {

adk-java (261 matches)

./CHANGELOG.md:100 — * add support for gemini models in VertexAiRagRetrieval (924fb71)
./CHANGELOG.md:223 — * Add VertexAiSearchTool and AgentTools for search (b48b194)
./CHANGELOG.md:335 — * Add VertexAiCodeExecutor (e5b1fb3)
./a2a/README.md:125 — nohup env GOOGLE_GENAI_USE_VERTEXAI=FALSE \
./a2a/README.md:135 — GOOGLE_GENAI_USE_VERTEXAI=FALSE \
./a2a/README.md:149 — nohup env GOOGLE_GENAI_USE_VERTEXAI=FALSE \
./contrib/samples/a2a_basic/README.md:33 — nohup env GOOGLE_GENAI_USE_VERTEXAI=FALSE \
./contrib/samples/mcpfilesystem/README.md:31 — export GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contrib/samples/mcpfilesystem/README.md:48 — export GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contrib/samples/mcpfilesystem/README.md:57 — export GOOGLE_GENAI_USE_VERTEXAI=FALSE
./contrib/spring-ai/src/test/java/com/google/adk/models/springai/integrations/GeminiApiIntegrationTest.java:60 — Client.builder().apiKey(System.getenv("GOOGLE_API_KEY")).vertexAI(false).build();
./contrib/spring-ai/src/test/java/com/google/adk/models/springai/integrations/GeminiApiIntegrationTest.java:102 — Client.builder().apiKey(System.getenv("GOOGLE_API_KEY")).vertexAI(false).build();
./contrib/spring-ai/src/test/java/com/google/adk/models/springai/integrations/GeminiApiIntegrationTest.java:147 — Client.builder().apiKey(System.getenv("GOOGLE_API_KEY")).vertexAI(false).build();
./contrib/spring-ai/src/test/java/com/google/adk/models/springai/integrations/GeminiApiIntegrationTest.java:191 — Client.builder().apiKey(System.getenv("GOOGLE_API_KEY")).vertexAI(false).build();
./contrib/spring-ai/src/test/java/com/google/adk/models/springai/integrations/GeminiApiIntegrationTest.java:298 — Client.builder().apiKey(System.getenv("GOOGLE_API_KEY")).vertexAI(false).build();
./core/src/main/java/com/google/adk/codeexecutors/VertexAiCodeExecutor.java:44 — * A code executor that uses Vertex Code Interpreter Extension to execute code.
./core/src/main/java/com/google/adk/codeexecutors/VertexAiCodeExecutor.java:50 — *
Follow https://cloud.google.com/vertex-ai/generative-ai/docs/extensions/code-interpreter for
./core/src/main/java/com/google/adk/codeexecutors/VertexAiCodeExecutor.java:53 — public final class VertexAiCodeExecutor extends BaseCodeExecutor {
./core/src/main/java/com/google/adk/codeexecutors/VertexAiCodeExecutor.java:54 — private static final Logger logger = LoggerFactory.getLogger(VertexAiCodeExecutor.class);
./core/src/main/java/com/google/adk/codeexecutors/VertexAiCodeExecutor.java:115 — * Initializes the VertexAiCodeExecutor.
./core/src/main/java/com/google/adk/codeexecutors/VertexAiCodeExecutor.java:120 — public VertexAiCodeExecutor(String resourceName) {
./core/src/main/java/com/google/adk/codeexecutors/VertexAiCodeExecutor.java:128 — "No resource name found for Vertex AI Code Interpreter. It will not be available.");
./core/src/main/java/com/google/adk/codeexecutors/VertexAiCodeExecutor.java:179 — logger.warn("Vertex AI Code Interpreter execution is not available. Returning empty result.");
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:39 — private static final String GOOGLE_GENAI_USE_VERTEXAI_ENV_VARIABLE_NAME =
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:40 — "GOOGLE_GENAI_USE_VERTEXAI";
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:100 — if (isVertexAiModel(modelName)) {
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:101 — apiClientBuilder.vertexAI(true);
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:142 — private static boolean isVertexAiModel(String model) {
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:145 — // "apigee/vertex_ai/" or the GOOGLE_GENAI_USE_VERTEXAI environment variable is set.
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:147 — && (model.startsWith("apigee/vertex_ai/")
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:148 — || isEnvEnabled(GOOGLE_GENAI_USE_VERTEXAI_ENV_VARIABLE_NAME));
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:158 — if (!components[0].equals("vertex_ai")
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:193 — *
{@code provider} (optional): {@code vertex_ai} or {@code gemini}. If omitted,
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:194 — * behavior depends on the {@code GOOGLE_GENAI_USE_VERTEXAI} environment variable. If that
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:207 — *
{@code apigee/vertex_ai/gemini-2.5-flash}
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:209 — *
{@code apigee/vertex_ai/v1beta/gemini-2.5-flash}
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:294 — if (!components[0].equals("vertex_ai") && !components[0].equals("gemini")) {
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:300 — if (components[0].equals("vertex_ai") || components[0].equals("gemini")) {
./core/src/main/java/com/google/adk/models/Gemini.java:212 — llmRequest, !apiClient.vertexAI(), /* stripThoughts= */ false);
./core/src/main/java/com/google/adk/models/Gemini.java:363 — if (!apiClient.vertexAI()) {
./core/src/main/java/com/google/adk/sessions/ApiClient.java:44 — final boolean vertexAI;
./core/src/main/java/com/google/adk/sessions/ApiClient.java:60 — this.vertexAI = false;
./core/src/main/java/com/google/adk/sessions/ApiClient.java:62 — this.httpOptions = defaultHttpOptions(/* vertexAI= */ false, this.location);
./core/src/main/java/com/google/adk/sessions/ApiClient.java:95 — this.httpOptions = defaultHttpOptions(/* vertexAI= */ true, this.location);
./core/src/main/java/com/google/adk/sessions/ApiClient.java:101 — this.vertexAI = true;
./core/src/main/java/com/google/adk/sessions/ApiClient.java:125 — public boolean vertexAI() {
./core/src/main/java/com/google/adk/sessions/ApiClient.java:126 — return vertexAI;
./core/src/main/java/com/google/adk/sessions/ApiClient.java:181 — static HttpOptions defaultHttpOptions(boolean vertexAI, @Nullable String location) {
./core/src/main/java/com/google/adk/sessions/ApiClient.java:191 — if (vertexAI && location != null) {
./core/src/main/java/com/google/adk/sessions/ApiClient.java:198 — } else if (vertexAI && Strings.isNullOrEmpty(location)) {
./core/src/main/java/com/google/adk/sessions/HttpApiClient.java:57 — if (this.vertexAI() && !path.startsWith("projects/") && !queryBaseModel) {
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:26 — /** Client for interacting with the Vertex AI Session API. */
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:27 — final class VertexAiClient {
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:30 — private static final Logger logger = LoggerFactory.getLogger(VertexAiClient.class);
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:34 — VertexAiClient(String project, String location, HttpApiClient apiClient) {
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:38 — VertexAiClient() {
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:42 — VertexAiClient(
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:93 — .flatMapMaybe(VertexAiClient::getJsonResponse)
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:111 — .flatMapMaybe(VertexAiClient::getJsonResponse);
./core/src/main/java/com/google/adk/sessions/VertexAiClient.java:120 — .flatMapMaybe(VertexAiClient::getJsonResponse);
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:45 — /** Connects to the managed Vertex AI Session Service. */
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:47 — public final class VertexAiSessionService implements BaseSessionService {
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:50 — private final VertexAiClient client;
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:53 — * Creates a new instance of the Vertex AI Session Service with a custom ApiClient for testing.
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:55 — public VertexAiSessionService(String project, String location, HttpApiClient apiClient) {
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:56 — this.client = new VertexAiClient(project, location, apiClient);
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:60 — public VertexAiSessionService() {
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:61 — this.client = new VertexAiClient();
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:65 — public VertexAiSessionService(
./core/src/main/java/com/google/adk/sessions/VertexAiSessionService.java:70 — this.client = new VertexAiClient(project, location, credentials, httpOptions);
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:24 — * A tool that wraps a sub-agent that only uses vertex_ai_search tool.
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:26 — *
This is a workaround to support using {@link VertexAiSearchTool} tool with other tools.
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:28 — public class VertexAiSearchAgentTool extends AgentTool {
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:30 — public static VertexAiSearchAgentTool create(
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:31 — BaseLlm model, VertexAiSearchTool vertexAiSearchTool) {
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:32 — LlmAgent vertexAiSearchAgent =
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:34 — .name("vertex_ai_search_agent")
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:37 — "An agent for performing Vertex AI search using the vertex_ai_search tool")
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:39 — " You are a specialized Vertex AI search agent.\n"
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:41 — + " When given a search query, use the vertex_ai_search tool to find"
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:43 — .tools(ImmutableList.of(vertexAiSearchTool))
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:45 — return new VertexAiSearchAgentTool(vertexAiSearchAgent);
./core/src/main/java/com/google/adk/tools/VertexAiSearchAgentTool.java:48 — protected VertexAiSearchAgentTool(LlmAgent agent) {
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:25 — import com.google.genai.types.VertexAISearch;
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:26 — import com.google.genai.types.VertexAISearchDataStoreSpec;
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:32 — * A built-in tool using Vertex AI Search.
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:34 — *
This tool can be configured with either a {@code dataStoreId} (the Vertex AI search data store
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:35 — * resource ID) or a {@code searchEngineId} (the Vertex AI search engine resource ID).
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:38 — public abstract class VertexAiSearchTool extends BaseTool {
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:41 — public abstract ImmutableList dataStoreSpecs();
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:56 — return new AutoValue_VertexAiSearchTool.Builder().dataStoreSpecs(ImmutableList.of());
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:59 — VertexAiSearchTool() {
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:60 — super("vertex_ai_search", "vertex_ai_search");
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:74 — "Vertex AI Search tool is only supported for Gemini models."));
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:77 — VertexAISearch.Builder vertexAiSearchBuilder = VertexAISearch.builder();
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:78 — dataStoreId().ifPresent(vertexAiSearchBuilder::datastore);
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:79 — searchEngineId().ifPresent(vertexAiSearchBuilder::engine);
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:80 — filter().ifPresent(vertexAiSearchBuilder::filter);
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:81 — maxResults().ifPresent(vertexAiSearchBuilder::maxResults);
./core/src/main/java/com/google/adk/tools/VertexAiSearchTool.java:83 — vertexAiSearchBuilder.dataStoreSpecs(dataStoreSpecs());

adk-js (85 matches)

./core/src/models/apigee_llm.ts:24 — * provider (optional): vertex_ai or gemini.
./core/src/models/apigee_llm.ts:32 — * - apigee/vertex_ai/gemini-2.5-flash
./core/src/models/apigee_llm.ts:34 — * - apigee/vertex_ai/v1beta/gemini-2.5-flash
./core/src/models/apigee_llm.ts:67 — vertexai,
./core/src/models/apigee_llm.ts:81 — ...apigeeToGeminiInitParams({model, vertexai, project, location, apiKey}),
./core/src/models/apigee_llm.ts:122 — components[0] != 'vertex_ai' &&
./core/src/models/apigee_llm.ts:130 — return this.vertexai ? 'v1beta1' : 'v1alpha';
./core/src/models/apigee_llm.ts:160 — vertexai,
./core/src/models/apigee_llm.ts:165 — const params = geminiInitParams({model, vertexai, project, location, apiKey});
./core/src/models/apigee_llm.ts:166 — params.vertexai =
./core/src/models/apigee_llm.ts:167 — params.vertexai || params.model?.startsWith('apigee/vertex_ai/');
./core/src/models/apigee_llm.ts:168 — if (params.vertexai) {
./core/src/models/apigee_llm.ts:205 — const validProviders = ['vertex_ai', 'gemini'];
./core/src/models/apigee_llm.ts:224 — // (e.g. apigee/vertex_ai/my-model)
./core/src/models/apigee_llm.ts:234 — // (e.g. apigee/vertex_ai/v1beta1/my-model)
./core/src/models/google_llm.ts:45 — vertexai?: boolean;
./core/src/models/google_llm.ts:47 — * The Vertex AI project ID. Required if vertexai is true.
./core/src/models/google_llm.ts:51 — * The Vertex AI location. Required if vertexai is true.
./core/src/models/google_llm.ts:65 — protected readonly vertexai: boolean;
./core/src/models/google_llm.ts:76 — vertexai,
./core/src/models/google_llm.ts:89 — vertexai,
./core/src/models/google_llm.ts:94 — if (!params.vertexai && !params.apiKey) {
./core/src/models/google_llm.ts:103 — this.vertexai = !!params.vertexai;
./core/src/models/google_llm.ts:236 — if (this.vertexai) {
./core/src/models/google_llm.ts:238 — vertexai: this.vertexai,
./core/src/models/google_llm.ts:254 — this._apiBackend = this.apiClient.vertexai
./core/src/models/google_llm.ts:255 — ? GoogleLLMVariant.VERTEX_AI
./core/src/models/google_llm.ts:264 — this.apiBackend === GoogleLLMVariant.VERTEX_AI ? 'v1beta1' : 'v1alpha';
./core/src/models/google_llm.ts:361 — vertexai,
./core/src/models/google_llm.ts:366 — const params: GeminiParams = {model, vertexai, project, location, apiKey};
./core/src/models/google_llm.ts:368 — params.vertexai = !!vertexai;
./core/src/models/google_llm.ts:369 — if (!params.vertexai && !isBrowser()) {
./core/src/models/google_llm.ts:370 — params.vertexai = getBooleanEnvVar('GOOGLE_GENAI_USE_VERTEXAI');
./core/src/models/google_llm.ts:373 — if (params.vertexai) {
./core/src/models/google_llm.ts:382 — 'VertexAI project must be provided via constructor or GOOGLE_CLOUD_PROJECT environment variable.',
./core/src/models/google_llm.ts:387 — 'VertexAI location must be provided via constructor or GOOGLE_CLOUD_LOCATION environment variable.',
./core/src/utils/variant_utils.ts:18 — VERTEX_AI = 'VERTEX_AI',
./core/src/utils/variant_utils.ts:30 — return getBooleanEnvVar('GOOGLE_GENAI_USE_VERTEXAI')
./core/src/utils/variant_utils.ts:31 — ? GoogleLLMVariant.VERTEX_AI
./core/test/models/apigee_llm_test.ts:20 — const vertexModelString = 'apigee/vertex_ai/model-id';
./core/test/models/apigee_llm_test.ts:27 — delete process.env['GOOGLE_GENAI_USE_VERTEXAI'];
./core/test/models/apigee_llm_test.ts:61 — it('vertexai is used if the model starts with apigee/vertex_ai/', () => {
./core/test/models/apigee_llm_test.ts:68 — expect(llm['vertexai']).toBe(true);
./core/test/models/apigee_llm_test.ts:71 — it('vertexai is used if GOOGLE_GENAI_USE_VERTEXAI is true', () => {
./core/test/models/apigee_llm_test.ts:72 — process.env['GOOGLE_GENAI_USE_VERTEXAI'] = 'true';
./core/test/models/apigee_llm_test.ts:79 — expect(llm['vertexai']).toBe(true);
./core/test/models/apigee_llm_test.ts:91 — 'vertexai with no project throws an error about missing GOOGLE_CLOUD_PROJECT',
./core/test/models/apigee_llm_test.ts:97 — 'vertexai with project but no location throws an error about missing GOOGLE_CLOUD_LOCATION',
./core/test/models/apigee_llm_test.ts:105 — 'vertexai with project and location but no proxy url throws an error about missing APIGEE_PROXY_URL',
./core/test/models/apigee_llm_test.ts:314 — 'apigee/vertex_ai/v1beta/model-id',
./core/test/models/apigee_llm_test.ts:319 — // Mock env vars for vertexai models to avoid other errors
./core/test/models/apigee_llm_test.ts:350 — {model: 'apigee/vertex_ai/model-id3', expected: 'model-id3'},
./core/test/models/apigee_llm_test.ts:353 — {model: 'apigee/vertex_ai/v1beta/model-id6', expected: 'model-id6'},
./core/test/models/apigee_llm_test.ts:415 — expect('apigee/vertex_ai/model-id').toMatch(modelRegex);
./core/test/models/apigee_llm_test.ts:418 — expect('apigee/vertex_ai/v1beta/model-id').toMatch(modelRegex);
./core/test/models/apigee_llm_test.ts:471 — 'apigee/vertex_ai/model-id (no version defaults to v1beta1)',
./core/test/models/apigee_llm_test.ts:475 — 'GOOGLE_GENAI_USE_VERTEXAI': 'true',
./core/test/models/apigee_llm_test.ts:481 — description: 'apigee/vertex_ai/v3/model-id uses v3',
./core/test/models/apigee_llm_test.ts:483 — model: 'apigee/vertex_ai/v3/model-id',
./core/test/models/apigee_llm_test.ts:488 — 'GOOGLE_GENAI_USE_VERTEXAI': 'true',
./core/test/models/google_llm_test.ts:26 — delete process.env['GOOGLE_GENAI_USE_VERTEXAI'];
./core/test/models/google_llm_test.ts:94 — expect(params.vertexai).toBe(false);
./core/test/models/google_llm_test.ts:117 — vertexai: true,
./core/test/models/google_llm_test.ts:122 — expect(params.vertexai).toBe(true);
./core/test/models/google_llm_test.ts:132 — vertexai: true,
./core/test/models/google_llm_test.ts:140 — process.env['GOOGLE_GENAI_USE_VERTEXAI'] = 'true';
./core/test/models/google_llm_test.ts:147 — expect(params.vertexai).toBe(true);
./core/test/models/google_llm_test.ts:153 — vertexai: true,
./core/test/models/google_llm_test.ts:156 — expect(() => geminiInitParams(input)).toThrow(/VertexAI project/);
./core/test/utils/variant_utils_test.ts:20 — delete process.env['GOOGLE_GENAI_USE_VERTEXAI'];
./core/test/utils/variant_utils_test.ts:24 — it('should return VERTEX_AI when GOOGLE_GENAI_USE_VERTEXAI is "true"', () => {
./core/test/utils/variant_utils_test.ts:25 — process.env = {...originalEnv, 'GOOGLE_GENAI_USE_VERTEXAI': 'true'};
./core/test/utils/variant_utils_test.ts:26 — expect(getGoogleLlmVariant()).toBe(GoogleLLMVariant.VERTEX_AI);
./core/test/utils/variant_utils_test.ts:29 — it('should return VERTEX_AI when GOOGLE_GENAI_USE_VERTEXAI is "1"', () => {
./core/test/utils/variant_utils_test.ts:30 — process.env = {...originalEnv, 'GOOGLE_GENAI_USE_VERTEXAI': '1'};
./core/test/utils/variant_utils_test.ts:31 — expect(getGoogleLlmVariant()).toBe(GoogleLLMVariant.VERTEX_AI);
./core/test/utils/variant_utils_test.ts:34 — it('should return GEMINI_API when GOOGLE_GENAI_USE_VERTEXAI is "false"', () => {
./core/test/utils/variant_utils_test.ts:35 — process.env = {...originalEnv, 'GOOGLE_GENAI_USE_VERTEXAI': 'false'};
./dev/src/cli/cli.ts:257 — 'Optional. The Google Cloud Project for using VertexAI as backend.',
./dev/src/cli/cli.ts:261 — 'Optional. The Google Cloud Region for using VertexAI as backend.',
./dev/src/cli/cli_create.ts:167 — lines.push(GOOGLE_GENAI_USE_VERTEXAI=0);
./dev/src/cli/cli_create.ts:176 — lines.push(GOOGLE_GENAI_USE_VERTEXAI=1);
./dev/src/cli/cli_deploy.ts:227 — ENV GOOGLE_GENAI_USE_VERTEXAI=1
./dev/test/cli/cli_create_test.ts:131 — expect.stringContaining('GOOGLE_GENAI_USE_VERTEXAI=1'),
./tests/integration/test_case_utils.ts:95 — public vertexai = false;

adk-docs (190 matches)

./.github/workflows/update-python-docs.yaml:61 — GOOGLE_GENAI_USE_VERTEXAI: 1
./docs/agents/config.md:91 — GOOGLE_GENAI_USE_VERTEXAI=0
./docs/agents/config.md:99 — GOOGLE_GENAI_USE_VERTEXAI=1
./docs/agents/config.md:297 — - VertexAiSearchTool
./docs/agents/models/google-gemini.md:110 — export GOOGLE_GENAI_USE_VERTEXAI=FALSE
./docs/agents/models/google-gemini.md:136 — export GOOGLE_CLOUD_LOCATION="YOUR_VERTEX_AI_LOCATION" # e.g., us-central1
./docs/agents/models/google-gemini.md:142 — export GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/agents/models/google-gemini.md:155 — export GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/agents/models/vertex.md:25 — export GOOGLE_CLOUD_LOCATION="YOUR_VERTEX_AI_LOCATION" # e.g., us-central1
./docs/agents/models/vertex.md:32 — export GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/agents/models/vertex.md:168 — Vars, GOOGLE_GENAI_USE_VERTEXAI=TRUE) is complete.
./docs/agents/models/vertex.md:200 — claude_model_vertexai = "claude-3-sonnet@20240229"
./docs/agents/models/vertex.md:202 — agent_claude_vertexai = LlmAgent(
./docs/agents/models/vertex.md:203 — model=claude_model_vertexai, # Pass the direct string after registration
./docs/agents/models/vertex.md:204 — name="claude_vertexai_agent",
./docs/agents/models/vertex.md:240 — public class ClaudeVertexAiAgent {
./docs/agents/models/vertex.md:244 — String claudeModelVertexAi = "claude-3-7-sonnet"; // Or any other Claude model
./docs/agents/models/vertex.md:257 — LlmAgent agentClaudeVertexAi = LlmAgent.builder()
./docs/agents/models/vertex.md:258 — .model(new Claude(claudeModelVertexAi, anthropicClient)) // Pass the Claude instance
./docs/agents/models/vertex.md:259 — .name("claude_vertexai_agent")
./docs/agents/models/vertex.md:265 — return agentClaudeVertexAi;
./docs/agents/models/vertex.md:291 — You can use the LiteLLM library to access open models like Meta's Llama on VertexAI MaaS
./docs/agents/models/vertex.md:299 — Vars, GOOGLE_GENAI_USE_VERTEXAI=TRUE) is complete.
./docs/agents/models/vertex.md:313 — agent_llama_vertexai = LlmAgent(
./docs/agents/models/vertex.md:314 — model=LiteLlm(model="vertex_ai/meta/llama-4-scout-17b-16e-instruct-maas"), # LiteLLM model string format
./docs/context/index.md:818 — * State Prefixes: While basic state is session-specific, prefixes like app: and user: can be used with persistent SessionService implementations (like DatabaseSessionService or `VertexAi
./docs/deploy/agent-engine/deploy.md:159 — agent_engine = vertexai.agent_engines.get('projects/123456789/locations/us-central1/reasoningEngines/751619551677906944')
./docs/deploy/cloud-run.md:59 — export GOOGLE_GENAI_USE_VERTEXAI=True
./docs/deploy/cloud-run.md:69 — export GOOGLE_GENAI_USE_VERTEXAI=FALSE
./docs/deploy/cloud-run.md:328 — --set-env-vars="GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT,GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION,GOOGLE_GENAI_USE_VERTEXAI=$GOOGLE_GENAI_USE_VERTEXAI"
./docs/deploy/cloud-run.md:571 — --set-env-vars="GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT,GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION,GOOGLE_GENAI_USE_VERTEXAI=$GOOGLE_GENAI_USE_VERTEXAI"
./docs/deploy/gke.md:11 — In this example we will deploy a simple agent to GKE. The agent will be a FastAPI application that uses Gemini 2.0 Flash as the LLM. We can use Vertex AI or AI Studio as the LLM provider using the E
./docs/deploy/gke.md:20 — export GOOGLE_GENAI_USE_VERTEXAI=true # Set to true if using Vertex AI
./docs/deploy/gke.md:322 — - name: GOOGLE_GENAI_USE_VERTEXAI
./docs/deploy/gke.md:323 — value: "$GOOGLE_GENAI_USE_VERTEXAI"
./docs/deploy/gke.md:324 — # If using AI Studio, set GOOGLE_GENAI_USE_VERTEXAI to false and set the following:
./docs/get-started/quickstart.md:306 — GOOGLE_GENAI_USE_VERTEXAI=FALSE
./docs/get-started/quickstart.md:313 — export GOOGLE_GENAI_USE_VERTEXAI=FALSE
./docs/get-started/quickstart.md:320 — GOOGLE_GENAI_USE_VERTEXAI=FALSE
./docs/get-started/quickstart.md:327 — export GOOGLE_GENAI_USE_VERTEXAI=FALSE
./docs/get-started/quickstart.md:341 — GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/get-started/quickstart.md:349 — export GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/get-started/quickstart.md:357 — GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/get-started/quickstart.md:365 — export GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/get-started/quickstart.md:379 — GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/get-started/quickstart.md:386 — export GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/get-started/quickstart.md:393 — GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/get-started/quickstart.md:400 — export GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/get-started/streaming/quickstart-streaming-java.md:112 — export GOOGLE_GENAI_USE_VERTEXAI=FALSE
./docs/get-started/streaming/quickstart-streaming.md:93 — GOOGLE_GENAI_USE_VERTEXAI=FALSE
./docs/get-started/streaming/quickstart-streaming.md:114 — GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/grounding/index.md:27 — - Understanding Vertex AI Search Grounding
./docs/grounding/vertex_ai_search_grounding.md:1 — # Vertex AI Search Grounding for agents
./docs/grounding/vertex_ai_search_grounding.md:7 — Vertex AI Search is a powerful tool for the Agent Development Kit (ADK) that enables AI agents to access information from your private enterprise docu
./docs/grounding/vertex_ai_search_grounding.md:11 — ## Preparing Vertex AI Search
./docs/grounding/vertex_ai_search_grounding.md:17 — Note: Vertex AI Search requires Google Cloud Platform (Vertex AI) authentication. Google AI Studio is not supported for this tool.
./docs/grounding/vertex_ai_search_grounding.md:19 — * Set up the gcloud CLI
./docs/grounding/vertex_ai_search_grounding.md:25 — GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/grounding/vertex_ai_search_grounding.md:32 — To enable Vertex AI Search Grounding, you include the search tool in your agent definition, providing the data_store_id.
./docs/grounding/vertex_ai_search_grounding.md:38 — from google.adk.tools import VertexAiSearchTool
./docs/grounding/vertex_ai_search_grounding.md:44 — name="vertex_search_agent",
./docs/grounding/vertex_ai_search_grounding.md:46 — instruction="Answer questions using Vertex AI Search to find information from internal documents. Always cite sources when available.",
./docs/grounding/vertex_ai_search_grounding.md:47 — description="Enterprise document search assistant with Vertex AI Search capabilities",
./docs/grounding/vertex_ai_search_grounding.md:48 — tools=[VertexAiSearchTool(data_store_id=DATASTORE_ID)]
./docs/grounding/vertex_ai_search_grounding.md:56 — import com.google.adk.tools.VertexAiSearchTool;
./docs/grounding/vertex_ai_search_grounding.md:62 — .name("vertex_search_agent")
./docs/grounding/vertex_ai_search_grounding.md:64 — .instruction("Answer questions using Vertex AI Search to find information from internal documents. Always cite sources when available.")
./docs/grounding/vertex_ai_search_grounding.md:65 — .description("Enterprise document search assistant with Vertex AI Search capabilities")
./docs/grounding/vertex_ai_search_grounding.md:66 — .tools(VertexAiSearchTool.builder().dataStoreId(DATASTORE_ID).build())
./docs/grounding/vertex_ai_search_grounding.md:70 — ## How grounding with Vertex AI Search works
./docs/grounding/vertex_ai_search_grounding.md:72 — Grounding with Vertex AI Search is the process that connects your agent to your organization's indexed documents and data, allowing it to generate accurate responses based on private enterprise conten
./docs/grounding/vertex_ai_search_grounding.md:78 —
./docs/grounding/vertex_ai_search_grounding.md:86 — 3. LLM Analysis and Tool-Calling: The agent's LLM (e.g., a Gemini model) analyzes the prompt. If it determines that information from your indexed documents is required, it triggers the grounding m
./docs/grounding/vertex_ai_search_grounding.md:87 — 4. Vertex AI Search Service Interaction: The VertexAiSearchTool interacts with your configured Vertex AI Search datastore, which contains your indexed enterprise documents. The service formulate
./docs/grounding/vertex_ai_search_grounding.md:88 — 5. Document Retrieval & Ranking: Vertex AI Search retrieves and ranks the most relevant document chunks from your datastore based on semantic similarity and relevance scoring.
./docs/grounding/vertex_ai_search_grounding.md:93 — ## Understanding grounding with Vertex AI Search response
./docs/grounding/vertex_ai_search_grounding.md:95 — When the agent uses Vertex AI Search to ground a response, it returns detailed information that includes the final text answer and metadata about the documents used to generate that answer. This metad
./docs/grounding/vertex_ai_search_grounding.md:157 — ## How to display grounding responses with Vertex AI Search
./docs/grounding/vertex_ai_search_grounding.md:159 — Unlike Google Search grounding, Vertex AI Search grounding does not require specific display components. However, displaying citations and document references builds trust and allows users to verify i
./docs/grounding/vertex_ai_search_grounding.md:198 — When implementing Vertex AI Search grounding displays:
./docs/integrations/bigquery-agent-analytics.md:106 — os.environ['GOOGLE_GENAI_USE_VERTEXAI'] = 'True'
./docs/integrations/cloud-trace.md:46 — os.environ.setdefault("GOOGLE_GENAI_USE_VERTEXAI", "True")
./docs/integrations/cloud-trace.md:108 — from vertexai.preview import reasoning_engines
./docs/integrations/cloud-trace.md:109 — from vertexai import agent_engines
./docs/integrations/cloud-trace.md:112 — import vertexai
./docs/integrations/cloud-trace.md:118 — vertexai.init(
./docs/integrations/express-mode.md:50 — GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/integrations/express-mode.md:59 — import vertexai
./docs/integrations/express-mode.md:60 — from vertexai import agent_engines
./docs/integrations/express-mode.md:67 — client = vertexai.Client(
./docs/integrations/express-mode.md:84 — ## Manage Sessions with VertexAiSessionService {#vertex-ai-session-service}
./docs/integrations/express-mode.md:86 — VertexAiSessionService
./docs/integrations/express-mode.md:91 — # Requires: pip install google-adk[vertexai]
./docs/integrations/express-mode.md:93 — # GOOGLE_GENAI_USE_VERTEXAI=TRUE
./docs/integrations/express-mode.md:95 — from google.adk.sessions import VertexAiSessionService
./docs/integrations/express-mode.md:101 — session_service = VertexAiSessionService(agent_engine_id=APP_ID)
./docs/integrations/express-mode.md:108 — For Free express mode Projects, VertexAiSessionService has the following quota:
./docs/integrations/express-mode.md:113 — ## Manage Memory with VertexAiMemoryBankService {#vertex-ai-memory-bank}
./docs/integrations/express-mode.md:115 — VertexAiMemoryBankService
./docs/integrations/express-mode.md:120 — # Requires: pip install google-adk[vertexai]

P2 — Configuration/Setup

Environment variables, config, model strings, setup code

adk-docs (1 matches)

./docs/agents/models/vertex.md:174 — pip install "anthropic[vertex]"

P3 — Documentation & Comments

Mentions in docs, comments, docstrings

adk-python (397 matches)

397 matches — showing first 30:

./.github/workflows/upload-adk-docs-to-vertex-ai-search.yml:1 — name: Upload ADK Docs to Vertex AI Search
./.github/workflows/upload-adk-docs-to-vertex-ai-search.yml:11 — upload-adk-docs-to-vertex-ai-search:
./AGENTS.md:33 — - Session - Conversation state management (in-memory, Vertex AI,
./AGENTS.md:91 — ├── sessions/ # Session management (in-memory, Vertex AI, Spanner)
./AGENTS.md:120 — Gemini Live API.
./CHANGELOG.md:57 — * Store and retrieve usage_metadata in Vertex AI custom_metadata (b318eee)
./CHANGELOG.md:64 — * Update eval extras to Vertex SDK package version with constrained LiteLLM upperbound (27cc98d)
./CHANGELOG.md:92 — * Store and retrieve usage_metadata in Vertex AI custom_metadata (b318eee)
./CHANGELOG.md:179 — * Store and retrieve EventCompaction via custom_metadata in Vertex AISessionService (2e434ca), closes [#3465](ht
./CHANGELOG.md:222 — * Add generate/create modes for Vertex AI Memory Bank writes (811e50a)
./CHANGELOG.md:223 — * Add support for memory consolidation via Vertex AI Memory Bank (4a88804)
./CHANGELOG.md:369 — * Mark Vertex calls made from non-Gemini models (7d58e0d)
./CHANGELOG.md:372 — * Allow Vertex AI Client initialization with API Key (43d6075)
./CHANGELOG.md:494 — * Handle NOT_FOUND error when fetching Vertex AI sessions (75231a3)
./CHANGELOG.md:773 — * Keep vertex session event after the session update time (0ec0195)
./CHANGELOG.md:844 — * Add api key argument to Vertex Session and Memory services for Express Mode support (9014a84)
./CHANGELOG.md:849 — * Add support for Vertex AI Express Mode when deploying to Agent Engine (d4b2a8b)
./CHANGELOG.md:850 — * Remove custom polling logic for Vertex AI Session Service since LRO polling is supported in express mode ([546c2a6](https://github.com/google/adk-python/commit/546c2a68165f54e694664d5b6b674056630178
./CHANGELOG.md:873 — * Disable SetModelResponseTool workaround for Vertex AI Gemini 2+ models (6a94af2)
./CHANGELOG.md:940 — * Introduces a new AgentEngineSandboxCodeExecutor class that supports executing agent-generated code using the Vertex AI Code Execution Sandbox API ([ee39a89](https://github.com/google/adk-python/comm
./CHANGELOG.md:1031 — * Add AuthConfig json serialization in vertex ai session service (636def3)
./CHANGELOG.md:1415 — * [Models]Add support for model-optimizer-* family of models in vertex (ffe2bdb)
./CHANGELOG.md:1649 — * Remove display_name for non-Vertex file uploads (cf5d701)
./CHANGELOG.md:1702 — * Fix filtering by user_id for vertex ai session service listing (9d4ca4e)
./README.md:40 — - New CodeExecutor: Introduces a new AgentEngineSandboxCodeExecutor class that supports executing agent-generated code using the Vertex AI Code Execution Sandbox API ([ee39a89](https://github.com/
./README.md:60 — scale seamlessly with Vertex AI Agent Engine.
./contributing/adk_project_overview_and_architecture.md:85 — The adk cli provides the "adk deploy" command to deploy to Google Vertex Agent Engine, Google CloudRun, Google GKE.
./contributing/samples/adk_answering_agent/gemini_assistant/agent.py:30 — """Searches Gemini API docs using Vertex AI Search.
./contributing/samples/adk_answering_agent/gemini_assistant/agent.py:47 — return error_response(f"Error creating Vertex AI Search client: {e}")
./contributing/samples/adk_answering_agent/gemini_assistant/agent.py:70 — return error_response(f"Error from Vertex AI Search: {e}")

adk-go (55 matches)

55 matches — showing first 30:

./internal/llminternal/file_uploads_processor.go:26 — // The Gemini API (non-Vertex) backend does not support the display_name parameter for file uploads,
./internal/llminternal/googlellm/variant.go:38 — // GoogleLLM is an interface which allows to distinguish between Vertex AI and Gemini API models.
./internal/llminternal/googlellm/variant.go:64 — // IsGeminiAPIVariant returns true if the model is a Gemini API model (not Vertex AI).
./internal/llminternal/outputschema_processor_test.go:166 — // Native support = Vertex AI + Gemini 2.5+
./internal/llminternal/outputschema_processor_test.go:172 — baseAgent := utils.Must(agent.New(agent.Config{Name: "VertexGemini2Agent"}))
./internal/telemetry/logger_test.go:164 — name: "RequestWithNilContentsVertexBackend",
./internal/telemetry/logger_test.go:393 — name: "ResponseVertexBackend",
./internal/telemetry/telemetry.go:38 — systemName = "gcp.vertex.agent"
./internal/telemetry/telemetry.go:45 — gcpVertexAgentToolCallArgsName = attribute.Key("gcp.vertex.agent.tool_call_args")
./internal/telemetry/telemetry.go:46 — gcpVertexAgentEventID = attribute.Key("gcp.vertex.agent.event_id")
./internal/telemetry/telemetry.go:47 — gcpVertexAgentToolResponseName = attribute.Key("gcp.vertex.agent.tool_response")
./internal/telemetry/telemetry.go:48 — gcpVertexAgentInvocationID = attribute.Key("gcp.vertex.agent.invocation_id")
./internal/telemetry/telemetry.go:68 — gcpVertexAgentInvocationID.String(invocationID), // used by adk-web
./internal/telemetry/telemetry.go:101 — gcpVertexAgentInvocationID.String(params.InvocationID),
./internal/telemetry/telemetry.go:121 — gcpVertexAgentEventID.String(params.EventID),
./internal/telemetry/telemetry.go:146 — gcpVertexAgentToolCallArgsName.String(safeSerialize(params.Args))))
./internal/telemetry/telemetry.go:170 — attributes = append(attributes, gcpVertexAgentEventID.String(params.ResponseEvent.ID))
./internal/telemetry/telemetry.go:189 — attributes = append(attributes, gcpVertexAgentToolResponseName.String(toolResponse))
./internal/telemetry/telemetry.go:243 — gcpVertexAgentToolCallArgsName.String("N/A"),
./internal/telemetry/telemetry.go:244 — gcpVertexAgentToolResponseName.String(safeSerialize(fnResponseEvent)),
./internal/telemetry/telemetry.go:247 — attributes = append(attributes, gcpVertexAgentEventID.String(fnResponseEvent.ID))
./internal/telemetry/telemetry_test.go:141 — gcpVertexAgentInvocationID: invocationID,
./internal/telemetry/telemetry_test.go:156 — gcpVertexAgentInvocationID: invocationID,
./internal/telemetry/telemetry_test.go:233 — gcpVertexAgentInvocationID: invocationID,
./internal/telemetry/telemetry_test.go:250 — gcpVertexAgentInvocationID: invocationID,
./model/apigee/apigee_test.go:120 — vertexEnv string
./model/apigee/apigee_test.go:127 — vertexEnv: "",
./model/apigee/apigee_test.go:131 — name: "simple vertex env",
./model/apigee/apigee_test.go:133 — vertexEnv: "true",
./model/apigee/apigee_test.go:139 — vertexEnv: "",

adk-java (91 matches)

91 matches — showing first 30:

./CHANGELOG.md:94 — * remove methods with Optional params from VertexCredential.Builder
./CHANGELOG.md:110 — * remove methods with Optional params from VertexCredential.Builder (0b9057c)
./CHANGELOG.md:276 — * Fixing a problem with serializing sessions that broke integration with Vertex AI Session Service (8190ed3)
./CHANGELOG.md:278 — * Fixing Vertex session storage (5607f64)
./contrib/spring-ai/README.md:70 — Vertex AI:
./contrib/spring-ai/README.md:74 — spring-ai-vertex-ai-gemini
./contrib/spring-ai/README.md:545 — 4. Vertex AI (spring-ai-vertex-ai-gemini)
./contrib/spring-ai/README.md:546 — - Models: Vertex AI Gemini models
./contrib/spring-ai/README.md:710 — - spring-ai-vertex-ai-gemini
./contrib/spring-ai/src/test/java/com/google/adk/models/springai/integrations/GeminiApiIntegrationTest.java:45 — *
Note: This uses the Google GenAI library directly, not Vertex AI. For Vertex AI integration,
./contrib/spring-ai/src/test/java/com/google/adk/models/springai/integrations/GeminiApiIntegrationTest.java:58 — // Create Google GenAI client using API key (not Vertex AI)
./core/src/main/java/com/google/adk/SchemaUtils.java:44 — // Based on types from https://cloud.google.com/vertex-ai/docs/reference/rest/v1/Schema
./core/src/main/java/com/google/adk/examples/ExampleUtils.java:66 — private static String convertExamplesToText(List examples) {
./core/src/main/java/com/google/adk/examples/ExampleUtils.java:168 — return convertExamplesToText(exampleProvider.getExamples(query));
./core/src/main/java/com/google/adk/flows/llmflows/audio/VertexSpeechClient.java:25 — /** Implementation of SpeechClientInterface using Vertex AI SpeechClient. */
./core/src/main/java/com/google/adk/flows/llmflows/audio/VertexSpeechClient.java:26 — public class VertexSpeechClient implements SpeechClientInterface {
./core/src/main/java/com/google/adk/flows/llmflows/audio/VertexSpeechClient.java:31 — * Constructs a VertexSpeechClient, initializing the underlying Google Cloud SpeechClient.
./core/src/main/java/com/google/adk/flows/llmflows/audio/VertexSpeechClient.java:35 — public VertexSpeechClient() throws IOException {
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:36 — * allows for specifying the provider (Gemini or Vertex AI), API version, and model ID.
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:143 — // If the model starts with "apigee/gemini/", it is not Vertex AI.
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:144 — // Otherwise, it is Vertex AI if either the user has explicitly set the model string to be
./core/src/main/java/com/google/adk/models/ApigeeLlm.java:185 — * Sets the model string. The model string specifies the LLM provider (e.g., Vertex AI, Gemini),
./core/src/main/java/com/google/adk/models/Gemini.java:98 — * @param vertexCredentials The Vertex AI credentials to access the Gemini model.
./core/src/main/java/com/google/adk/models/Gemini.java:100 — public Gemini(String modelName, VertexCredentials vertexCredentials) {
./core/src/main/java/com/google/adk/models/Gemini.java:102 — Objects.requireNonNull(vertexCredentials, "vertexCredentials cannot be null");
./core/src/main/java/com/google/adk/models/Gemini.java:105 — vertexCredentials.project().ifPresent(apiClientBuilder::project);
./core/src/main/java/com/google/adk/models/Gemini.java:106 — vertexCredentials.location().ifPresent(apiClientBuilder::location);
./core/src/main/java/com/google/adk/models/Gemini.java:107 — vertexCredentials.credentials().ifPresent(apiClientBuilder::credentials);
./core/src/main/java/com/google/adk/models/Gemini.java:113 — * Gemini object, at least one of apiKey, vertexCredentials, or an explicit apiClient must be set.
./core/src/main/java/com/google/adk/models/Gemini.java:127 — private VertexCredentials vertexCredentials;

adk-js (64 matches)

64 matches — showing first 30:

./core/src/examples/example_util.ts:33 — export function convertExamplesToText(
./core/src/examples/example_util.ts:96 — return convertExamplesToText(examples, model);
./core/src/examples/example_util.ts:99 — return convertExamplesToText(examples.getExamples(query), model);
./core/src/models/apigee_llm.ts:21 — * (e.g., Vertex AI, Gemini), API version, and the model ID. Supported format:
./core/src/models/apigee_llm.ts:129 — // Default to v1beta1 for vertex AI and v1alpha for Gemini.
./core/src/models/google_llm.ts:42 — * Whether to use Vertex AI. If true, project, location
./core/src/models/google_llm.ts:113 — // fine-tuned vertex endpoint pattern
./core/src/models/google_llm.ts:115 — // vertex gemini long name
./core/src/models/google_llm.ts:353 — // display_name is not supported for Gemini API (non-vertex)
./core/src/telemetry/tracing.ts:38 — export const tracer = trace.getTracer('gcp.vertex.agent', version);
./core/src/telemetry/tracing.ts:120 — 'gcp.vertex.agent.llm_request': '{}',
./core/src/telemetry/tracing.ts:121 — 'gcp.vertex.agent.llm_response': '{}',
./core/src/telemetry/tracing.ts:122 — 'gcp.vertex.agent.tool_call_args': shouldAddRequestResponseToSpans()
./core/src/telemetry/tracing.ts:147 — 'gcp.vertex.agent.event_id': functionResponseEvent.id,
./core/src/telemetry/tracing.ts:148 — 'gcp.vertex.agent.tool_response': shouldAddRequestResponseToSpans()
./core/src/telemetry/tracing.ts:179 — 'gcp.vertex.agent.tool_call_args': 'N/A',
./core/src/telemetry/tracing.ts:180 — 'gcp.vertex.agent.event_id': responseEventId,
./core/src/telemetry/tracing.ts:183 — 'gcp.vertex.agent.llm_request': '{}',
./core/src/telemetry/tracing.ts:184 — 'gcp.vertex.agent.llm_response': '{}',
./core/src/telemetry/tracing.ts:188 — 'gcp.vertex.agent.tool_response',
./core/src/telemetry/tracing.ts:222 — 'gen_ai.system': 'gcp.vertex.agent',
./core/src/telemetry/tracing.ts:224 — 'gcp.vertex.agent.invocation_id': invocationContext.invocationId,
./core/src/telemetry/tracing.ts:225 — 'gcp.vertex.agent.session_id': invocationContext.session.id,
./core/src/telemetry/tracing.ts:226 — 'gcp.vertex.agent.event_id': eventId,
./core/src/telemetry/tracing.ts:228 — 'gcp.vertex.agent.llm_request': shouldAddRequestResponseToSpans()
./core/src/telemetry/tracing.ts:246 — 'gcp.vertex.agent.llm_response',
./core/src/telemetry/tracing.ts:300 — 'gcp.vertex.agent.invocation_id': invocationContext.invocationId,
./core/src/telemetry/tracing.ts:301 — 'gcp.vertex.agent.event_id': eventId,
./core/src/telemetry/tracing.ts:308 — 'gcp.vertex.agent.data',
./core/src/utils/variant_utils.ts:16 — * For using credentials from Google Vertex AI

adk-docs (286 matches)

286 matches — showing first 30:

./README.md:44 — scale seamlessly with Vertex AI Agent Engine.
./docs/agents/models/anthropic.md:3 —
./docs/agents/models/anthropic.md:8 — or from a Vertex AI backend into your Java ADK applications by using the ADK's
./docs/agents/models/anthropic.md:10 — Google Cloud Vertex AI services. For more information, see the
./docs/agents/models/anthropic.md:11 — Third-Party Models on Vertex AI
./docs/agents/models/apigee.md:10 — exposing your AI model endpoint (like Vertex AI or the Gemini API) through an
./docs/agents/models/apigee.md:23 — The ApigeeLLM wrapper is currently designed for use with Vertex AI
./docs/agents/models/google-gemini.md:79 — This section covers authenticating with Google's Gemini models, either through Google AI Studio for rapid development or Google Cloud Vertex AI for enterprise applications. This is the most direct way
./docs/agents/models/google-gemini.md:88 — through either Google AI Studio or Vertex AI.
./docs/agents/models/google-gemini.md:97 — - Vertex AI: Gemini Live API
./docs/agents/models/google-gemini.md:120 — ### Google Cloud Vertex AI
./docs/agents/models/google-gemini.md:122 — For scalable and production-oriented use cases, Vertex AI is the recommended platform. Gemini on Vertex AI supports enterprise-grade features, security, and compliance controls. Based on your developm
./docs/agents/models/google-gemini.md:139 — Explicitly tell the library to use Vertex AI:
./docs/agents/models/google-gemini.md:146 — Vertex AI documentation.
./docs/agents/models/google-gemini.md:148 — ### Method B: Vertex AI Express Mode
./docs/agents/models/google-gemini.md:149 — Vertex AI Express Mode offers a simplified, API-key-based setup for rapid prototyping.
./docs/agents/models/google-gemini.md:162 — 1. Create a Service Account and grant it the Vertex AI User role.
./docs/agents/models/index.md:15 — such as Gemini models accessed via Google AI Studio or Vertex AI, or models
./docs/agents/models/index.md:16 — hosted on Vertex AI endpoints. You access these models by providing the model name or endpoint resource string and ADK's internal registry
./docs/agents/models/index.md:21 — * Vertex AI hosted models
./docs/agents/models/litellm.md:22 — LLMs from providers like OpenAI, Anthropic (non-Vertex AI), Cohere, and many
./docs/agents/models/litellm.md:68 — * Example for Anthropic (non-Vertex AI):
./docs/agents/models/litellm.md:93 — # --- Example Agent using Anthropic's Claude Haiku (non-Vertex) ---
./docs/agents/models/vertex.md:1 — # Vertex AI hosted models for ADK agents
./docs/agents/models/vertex.md:4 — Cloud's MLOps ecosystem, you can use models deployed to Vertex AI Endpoints.
./docs/agents/models/vertex.md:7 — Integration Method: Pass the full Vertex AI Endpoint resource string
./docs/agents/models/vertex.md:11 — ## Vertex AI Setup
./docs/agents/models/vertex.md:13 — Ensure your environment is configured for Vertex AI:
./docs/agents/models/vertex.md:28 — 3. Enable Vertex Backend: Crucially, ensure the google-genai library
./docs/agents/models/vertex.md:29 — targets Vertex AI:

Analysis

Key Patterns

VertexAI is deeply integrated across all ADK SDKs. Every repo has significant Vertex AI mentions.
Core Vertex AI services used across SDKs:
- VertexAiSessionService — managed session persistence
- VertexAiSearchTool — enterprise document search grounding
- VertexAiRagRetrieval / VertexAiRagMemoryService — RAG engine integration
- VertexAiMemoryBankService — managed memory
- VertexAiExampleStore — example management
No raw HTTP calls (P0) in application code — all Vertex AI access goes through the google-genai SDK or equivalent. P0 matches are only in OpenAPI spec docs and documentation references to aiplatform.googleapis.com.
GOOGLE_GENAI_USE_VERTEXAI env var is the primary toggle between Google AI Studio and Vertex AI backends, used across all languages.
adk-python has by far the most mentions (~1400) as the most mature SDK.
adk-js has the fewest mentions (~150), with Vertex AI primarily in the Apigee LLM proxy layer and docs.
adk-docs contains ~500 mentions, heavily focused on deployment guides (Agent Engine, Cloud Run, GKE) and grounding docs.

Concerns

No direct Vertex AI API calls were found (P0 is all docs/specs) — all access is properly abstracted through SDKs. ✅
Consistent patterns across languages for session/memory/search services. ✅
Feature parity gap: adk-js lacks Vertex AI RAG, Memory Bank, and Search tools that Python/Java/Go have.
Heavy Vertex AI coupling in deployment docs — alternative deployment paths less documented.

zeroasterisk/vertex-audit.md

Select an option

No results found