Generate Images with Google's Gemini API: A Node.js Application
Generate Images with Google's Gemini API: A Node.js Application
AI image generation is revolutionizing creative workflows. This blog post details the development of a Node.js application, the Gemini Image Generator, that harnesses Google's Gemini API to produce images from text prompts. We'll cover the technical implementation, API endpoints, and considerations for building a robust and efficient image generation service.
Project Overview
The Gemini Image Generator is a lightweight REST API enabling users to submit text prompts and receive AI-generated images. Built using Node.js, Express.js, and Google's Generative AI SDK, it offers a streamlined solution for image creation.
Key Features:
- Accepts text prompts for image generation.
- Utilizes Google's Gemini API for AI-powered image synthesis.
- Saves generated images on the server (consider cloud storage for scalability).
- Provides REST API endpoints for seamless integration with other applications.
Tech Stack
- Node.js: Backend runtime environment.
- Express.js: Lightweight and flexible web framework.
- Google Generative AI SDK: Facilitates interaction with the Gemini API.
- dotenv: Manages environment variables for secure API key handling.
- cors: Enables cross-origin resource sharing for broader application integration.
Getting Started
1. Clone the Repository
git clone https://github.com/manthanank/gemini-image-generator.git
cd gemini-image-generator2. Install Dependencies
npm install3. Configure Environment Variables
Create a .env file in the project's root directory and add your Google Gemini API key:
GEMINI_API_KEY=your_google_gemini_api_key
PORT=50004. Start the Server
npm startThe server will be accessible at http://localhost:5000.
API Endpoints
Generate an Image
Endpoint: POST /api/image/generate
Request Body:
{
"prompt": "a futuristic cityscape with neon lights"
}Response:
{
"message": "Image generated successfully",
"imagePath": "temp/generated_image.png"
}Project Structure
gemini-image-generator/
├── controllers/ // Business logic
├── routes/ // API routes
├── services/ // Google Gemini AI logic
├── temp/ // Generated images
├── server.js // Entry point
├── package.json // Dependencies
└── .env // Environment variables
Core Implementation
1. Setting Up the Express Server
The server.js file initializes the Express application and starts the server:
const app = require("./app");
const { port } = require("./config/env");
app.listen(port, () => {
console.log(`Server running on http://localhost:${port}`);
});2. Handling Image Generation Requests
The imageController.js file handles incoming requests, validating the prompt and calling the Gemini API service:
const { generateImage } = require("../services/geminiService");
async function generateImageController(req, res) {
const { prompt } = req.body;
if (!prompt) {
return res.status(400).json({ error: "Prompt is required" });
}
try {
const imagePath = await generateImage(prompt);
res.status(200).json({ message: "Image generated successfully", imagePath });
} catch (error) {
res.status(500).json({ error: error.message });
}
}
module.exports = { generateImageController };3. Integrating the Gemini API
The geminiService.js file interacts with the Google Gemini API:
const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");
const path = require("path");
const { geminiApiKey } = require("../config/env");
const genAI = new GoogleGenerativeAI(geminiApiKey);
async function generateImage(prompt) {
const model = genAI.getGenerativeModel({
model: "gemini-2.0-flash-exp-image-generation",
generationConfig: { responseModalities: ['Text', 'Image'] }
});
try {
const response = await model.generateContent(prompt);
for (const part of response.response.candidates[0].content.parts) {
if (part.inlineData) {
const imageData = part.inlineData.data;
const buffer = Buffer.from(imageData, 'base64');
const filePath = path.join(__dirname, '../temp/generated_image.png');
fs.writeFileSync(filePath, buffer);
return filePath;
}
}
} catch (error) {
console.error("Error generating image:", error);
throw new Error("Failed to generate image");
}
}
module.exports = { generateImage };Conclusion
This project demonstrates a practical implementation of Google's Gemini API for image generation. Further development could incorporate features like image style selection, real-time previews, and integration with cloud storage for enhanced scalability and reliability. Remember to always handle API keys securely and consider error handling and rate limiting for a production-ready application.
Related Articles
Software Development
Unveiling the Haiku License: A Fair Code Revolution
Dive into the innovative Haiku License, a game-changer in open-source licensing that balances open access with fair compensation for developers. Learn about its features, challenges, and potential to reshape the software development landscape. Explore now!
Read MoreSoftware Development
Leetcode - 1. Two Sum
Master LeetCode's Two Sum problem! Learn two efficient JavaScript solutions: the optimal hash map approach and a practical two-pointer technique. Improve your coding skills today!
Read MoreBusiness, Software Development
The Future of Digital Credentials in 2025: Trends, Challenges, and Opportunities
Digital credentials are transforming industries in 2025! Learn about blockchain's role, industry adoption trends, privacy enhancements, and the challenges and opportunities shaping this exciting field. Discover how AI and emerging technologies are revolutionizing identity verification and workforce management. Explore the future of digital credentials today!
Read More
