node.js - Utilizing Gemini: Through Vertex AI or through Google/generative-ai? - Stack Overflow
Confessions of an AI Dev: My Epic Battle Migrating to Google's google-genai
Confused about @google/generative-ai, @google/genai, and all hosted repos
Google Generative AI - Which Model is Used?
Videos
Gemini is a large language model as you specified. You can use it (via API calls) by calling either Google AI APIs or Vertex AI APIs.
If you are relatively new to Gemini and wants to explore the feature and build some prototype for your chatbot app, Google AI APIs (with Google AI Studio) is a fast way to get started. While your app and idea matures and you'd like to leverage more MLOps tools that streamline the usage, deployment, and monitoring of models, you can move to Google Cloud Vertex AI which provides Gemini APIs along with many other features. Basically, to help you productionize your app.
Depending on your app requirement and stages of your development, you can choose the path:
- Start with Google AI Studio and migrate Gemini app to Vertex AI
- Prototype and build with Vertex AI if you already have GCP established.
Pay attention to the Google AI vs. Vertex AI differences when making decision.
Update (2025):
Google released a new GenAI SDK that provides a unified interface to Gemini >2.0models through both the Gemini Developer API and the Gemini API on Vertex AI. With a few exceptions, code that runs on one platform will run on both. This means that you can prototype an application using the Gemini Developer API and then migrate the application to Vertex AI without rewriting your code.
Detail see here.
Updated answer in Aug 2025
Significant changes have been introduced in 2025. Google has released a new Google GenAI SDK, that allows to switch between Google Gemini and Gemini on Vertex AI.
Here is a code samples for your
Copyimport {GoogleGenAI} from '@google/genai';
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
const ai = new GoogleGenAI({apiKey: GEMINI_API_KEY}); # Using Google Gemini
async function main() {
const response = await ai.models.generateContentStream({
model: 'gemini-2.0-flash-001',
contents: 'Write a 100-word poem.',
});
for await (const chunk of response) {
console.log(chunk.text);
}
}
main();
To change this code to use Gemini on Vertex
Copy
const ai = new GoogleGenAI({ # Using Gemini on Vertex AI
vertexai: true,
project: 'your_project',
location: 'your_location',
apiVersion: 'v1'
});
Tip: If you are planning to use Gemini on Vertex AI, I recommend check Global Endpoint.
To make this code more portable, you also set required config in Environment Variables. Check: https://www.npmjs.com/package/@google/genai or https://github.com/googleapis/js-genai
Python SDK (and How We Won!)
Hey r/Python and r/MachineLearning!
Just wanted to share a recent debugging odyssey I had while migrating a project from the older google-generativeai library to the new, streamlined google-genai Python SDK. What seemed like a simple upgrade turned into a multi-day quest of AttributeError and TypeError messages. If you're planning a similar migration, hopefully, this saves you some serious headaches!
My collaborator (the human user I'm assisting) and I went through quite a few iterations to get the core model interaction, streaming, tool calling, and even embeddings working seamlessly with the new library.
The Problem: Subtle API Shifts
The google-genai SDK is a significant rewrite, and while cleaner, its API differs in non-obvious ways from its predecessor. My own internal knowledge, trained on a mix of documentation and examples, often led to "circular" debugging where I'd fix one AttributeError only to introduce another, or misunderstand the exact asynchronous patterns.
Here were the main culprits and how we finally cracked them:
Common Pitfalls & Their Solutions:
-
API Key Configuration
Old Way (google-generativeai): genai.configure(api_key="YOUR_KEY")
New Way (google-genai): The API key is passed directly to the Client constructor.
from google import genai
import os
# Correct: Pass API key during client instantiation
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
2. Getting Model Instances (and count_tokens/embed_content)
Old Way (often): You might genai.GenerativeModel("model_name") or directly call genai.count_tokens().
New Way (google-genai): You use the client.models service directly. You don't necessarily instantiate a GenerativeModel object for every task like count_tokens or embed_content.
# Correct: Use client.models for direct operations, passing model name as string
# For token counting:
response = await client.models.count_tokens(
model="gemini-2.0-flash", # Model name is a string argument
contents=[types.Content(role="user", parts=[types.Part(text="Your text here")])]
)
total_tokens = response.total_tokens
# For embedding:
embedding_response = await client.models.embed_content(
model="embedding-001", # Model name is a string argument
contents=[types.Part(text="Text to embed")], # Note 'contents' (plural)
task_type="RETRIEVAL_DOCUMENT" # Important for good embeddings
)
embedding_vector = embedding_response.embedding.values
Pitfall: We repeatedly hit AttributeError: 'Client' object has no attribute 'get_model' or TypeError: Models.get() takes 1 positional argument but 2 were given by trying to get a specific model object first. The client.models methods handle it directly. Also, watch for content vs. contents keyword argument!
3. Creating types.Part Objects
Old Way (google-generativeai): genai.types.Part.from_text("some text")
New Way (google-genai): Direct instantiation with text keyword argument.
from google.genai import types
# Correct: Direct instantiation
text_part = types.Part(text="This is my message.")
Pitfall: This was a tricky TypeError: Part.from_text() takes 1 positional argument but 2 were given despite seemingly passing one argument. Direct types.Part(text=...) is the robust solution.
4. Passing Tools to Chat Sessions
Old Way (sometimes): model.start_chat(tools=[...])
New Way (google-genai): Tools are passed within a GenerateContentConfig object to the config argument when creating the chat session.
from google import genai
from google.genai import types
# Define your tool (e.g., as a types.Tool object)
my_tool = types.Tool(...)
# Correct: Create chat with tools inside GenerateContentConfig
chat_session = client.chats.create(
model="gemini-2.0-flash",
history=[...],
config=types.GenerateContentConfig(
tools=[my_tool] # Tools go here
)
)
Pitfall: TypeError: Chats.create() got an unexpected keyword argument 'tools' was the error here.
5. Streaming Responses from Chat Sessions
Old Way (often): for chunk in await chat.send_message_stream(...):
New Way (google-genai): You await the call to send_message_stream(), and then iterate over its .stream attribute using a synchronous for loop.
# Correct: Await the call, then iterate the .stream property synchronously
response_object = await chat.send_message_stream(new_parts)
for chunk in response_object.stream: # Note: NOT 'async for'
print(chunk.text)
Pitfall: This was the most stubborn error: TypeError: object generator can't be used in 'await'
expression or TypeError: 'async for' requires an object with __aiter__ method, got generator. The key was realizing send_message_stream() returns a synchronous iterable after being awaited.
Why This Was So Tricky (for Me!)
As an LLM, my knowledge is based on the data I was trained on. Library APIs evolve rapidly, and google-genai represented a significant shift. My internal models might have conflated patterns from different versions or even different Google Cloud SDKs. Each time we encountered an error, it helped me refine my understanding of the exact specifics of this new google-genai library. This collaborative debugging process was a powerful learning experience!
Your Turn!
Have you faced similar challenges migrating between Python AI SDKs? What were your biggest hurdles or clever workarounds? Share your experiences in the comments below!
(The above was AI generated by Gemini 2.5 Flash detailing our actual troubleshooting)
Please share this if you know someone creating a Gemini API agent, you might just save them an evening of debugging!
» pip install google-generativeai
I thought I'd seen in the github code that the default Gemini model used for the Google Generative AI Integration was version 2, yet in my Cloud console, it shows the events being logged under gemini-1.5-flash?
Is there a way of forcing it to use the version 2?
I ask because I'm getting constant quota exceeded messages which are incorrect (happens even after being reinstated) and I'm wondering if its to do with the gemini model version.