How to use Google Gemini API for code generation apps

1. What you are using (Gemini API context)

The Gemini API is provided by Google through its Google AI / Gemini platform, accessible via Google AI Studio and Vertex AI.

For code generation apps, you’ll typically use:

• Gemini 1.5 Flash → low latency, cost-efficient (good default for IDE assistants)
• Gemini 1.5 Pro → higher reasoning quality (better for complex code generation/refactoring)

2. Setup options (choose one)

Option A — Google AI Studio (fastest for prototyping)

• No infrastructure setup
• API key-based access

Option B — Vertex AI (production)

• IAM-based authentication
• Better scaling, enterprise controls

For most code-generation apps, start with AI Studio, then migrate to Vertex AI.

3. Installation

Python

pip install google-genai

Node.js

npm install @google/genai

4. Basic API usage (core pattern)

Python example

from google import genai

client = genai.Client(api_key="YOUR_API_KEY")

response = client.models.generate_content(
    model="gemini-1.5-flash",
    contents="Write a Python function that validates an email address."
)

print(response.text)

Node.js example

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

const response = await ai.models.generateContent({
  model: "gemini-1.5-flash",
  contents: "Write a JavaScript function that debounces input."
});

console.log(response.text);

5. Designing prompts for code generation apps

This is the most important part.

A. Use structured prompts

Instead of:

“write login code”

Use:

You are a senior software engineer.

Task:
Generate production-ready Python FastAPI login endpoint.

Requirements:
- JWT authentication
- bcrypt password hashing
- Input validation
- Return proper HTTP status codes

Output:
- Full working code
- Include imports
- No explanations

B. Use role separation (system-style instruction)

Gemini supports instruction-like prompting:

You are an expert backend engineer specializing in secure APIs.
Always produce production-ready code with no pseudocode.

Then user request:

Create a Node.js Express rate limiter middleware.

C. Force structured outputs (important for apps)

If building a code tool, you often want JSON:

Return output in JSON:
{
  "filename": "",
  "language": "",
  "code": ""
}

This makes IDE integration easier.

6. Streaming responses (for IDE-like UX)

For real code-generation apps (like Copilot-style UX), streaming is essential.

Python streaming

for chunk in client.models.generate_content_stream(
    model="gemini-1.5-flash",
    contents="Write a React hook for API fetching"
):
    print(chunk.text, end="")

7. Multi-file / project-aware generation

Gemini 1.5 models support long context (useful for codebases).

Example:

You are given a codebase.

File: auth.py
<content>

File: db.py
<content>

Task:
Refactor authentication to use async DB calls.
Return only modified files.

9. Advanced techniques (important for quality)

A. Retrieval-Augmented Generation (RAG)

Use when user references a project:

1. Embed codebase
2. Retrieve relevant files
3. Inject into prompt

Example prompt:

Context:
<retrieved files>

Task:
Fix bug in authentication flow.

B. Tool calling (for “smart IDE” features)

You can build tools like:

• “search file”
• “run tests”
• “lint code”

Then instruct Gemini:

If needed, call tools to inspect code before answering.

C. Temperature control

For code generation:

• temperature: 0.1–0.3 → deterministic, safer
• temperature: 0.7+ → creative (not recommended for production code)

12. Example: full mini code-gen API endpoint (Node.js)

import express from "express";
import { GoogleGenAI } from "@google/genai";

const app = express();
app.use(express.json());

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

app.post("/generate", async (req, res) => {
  const { prompt } = req.body;

  const response = await ai.models.generateContent({
    model: "gemini-1.5-flash",
    contents: `
You are a code generator.
Return only code.

Task:
${prompt}
`
  });

  res.json({ code: response.text });
});

app.listen(3000)