Firebase AI Logic: lleva Gemini directo a tu frontend
12 nov. 2025

La inteligencia artificial está transformando la forma en que construimos aplicaciones. Pero integrar un modelo generativo — como Gemini — suele implicar configurar APIs, credenciales y un backend que actúe como intermediario.
Ahí es donde entra Firebase AI Logic: una nueva forma de usar la IA directamente desde tu app, con apenas unas líneas de código y toda la potencia del ecosistema Firebase.
En este artículo exploraremos qué es Firebase AI Logic, cómo habilitarlo paso a paso, y construiremos una app donde podremos generar recetas usando los modelos de Google.
¿Qué es Firebase AI Logic?
Firebase AI Logic simplifica llevar las capacidades de IA directamente al cliente (client-side), sin necesidad de un backend personalizado.
Tiene soporte para Android, iOS, Web, Flutter y Unity, lo que permite integrar experiencias de IA generativa en casi cualquier tipo de proyecto con Firebase.
Características principales
- Acceso a Gemini: permite conectarte fácilmente a los modelos de Google para generar texto, imágenes o respuestas multimodales, todo desde tu entorno Firebase.
- IA Híbrida (Hybrid Inference): ejecuta la IA directamente en el dispositivo (por ejemplo, con Gemini Nano en Chrome o Android). Si no es posible, la inferencia pasa automáticamente al modelo en la nube, equilibrando rendimiento, privacidad y costos.
- Monitoreo: desde la consola de Firebase puedes acceder a métricas de uso, rendimiento y depuración.
- Integración con Firebase: se integra con otros servicios de Firebase como Firebase Remote Config, App Check y Cloud Storage.

Para este ejemplo, replicaremos parte de la aplicación de recetas saludables que construí hace unos meses con Genkit, donde mostré cómo usar Gemini para generar recetas.
Si aún no has leído ese artículo, puedes revisarlo aquí: Food Fit: tu partner para tener una alimentación saludable con Genkit.
En esta ocasión, veremos cómo lograr algo similar pero directamente desde el frontend, sin backend intermedio.
Ahora que comprendemos qué hace Firebase AI Logic y sus principales ventajas, es momento de ponerlo en acción configurando nuestro entorno.
Configuración inicial
Antes de empezar, asegúrate de cumplir con los siguientes requisitos:
- Tener un proyecto de Firebase configurado.
- Habilitar
Firebase AI Logicdesde la consola de Firebase (en la secciónAI→AI Logic). - Instalar el SDK correspondiente a tu entorno (en este caso,
Web).
Inicialización del entorno y dependencias
Antes de usar Firebase AI Logic, debemos inicializar Firebase y obtener acceso al SDK. En este caso, también configuramos el backend de Vertex AI, que será el responsable de ejecutar las solicitudes al modelo Gemini.
import { Injectable } from '@angular/core';
import { initializeApp } from "firebase/app";
import { getAI, VertexAIBackend } from "firebase/ai";
// We initialize the Firebase app using the environment configuration
const firebaseApp = initializeApp(environment.firebaseConfig);
// We obtain an instance of the Firebase AI module.
// This is where we define the backend to be used.
const ai = getAI(firebaseApp, {
backend: new VertexAIBackend()
});
La clase VertexAIBackend actúa como el puente entre tu app y los modelos de Google Gemini.
Con Firebase y Vertex AI inicializados, podemos continuar configurando el modelo generativo que usaremos en la app.
Configuración del modelo generativo
Ahora configuramos el modelo Gemini que usaremos para generar las recetas. Aquí recurrimos al modelo en la nube; además, configuramos la estructura de salida.
const model = getGenerativeModel(ai, {
model: 'gemini-2.5-flash-lite',
generationConfig: {
responseMimeType: "application/json",
responseSchema: outputFoodItemSchema
}
});
Ahora que hemos definido el modelo, necesitamos establecer cómo lucirá la estructura de los datos que recibiremos.
Definición del esquema de salida
Para estructurar la respuesta del modelo, definimos un esquema con Schema. Esto asegura que la respuesta tenga un formato JSON.
const outputFoodItemSchema = Schema.object({
properties: {
recipes: Schema.array({
items: Schema.object({
properties: {
name: Schema.string(),
description: Schema.string(),
ingredients: Schema.array({
items: Schema.string()
}),
nutritional_information: Schema.object({
properties: {
cal: Schema.number(),
carbohydrates: Schema.number(),
fats: Schema.number(),
sodium: Schema.number(),
cholesterol: Schema.number(),
proteins: Schema.number()
}
}),
preparation_time: Schema.string(),
level: Schema.string(),
preparation: Schema.array({
items: Schema.string()
})
}
})
})
}
});
Este esquema garantiza que la respuesta del modelo llegue en un formato consistente, lista para ser usada directamente en el frontend.
Una vez que el modelo de texto está listo, podemos hacer lo mismo para generar imágenes con Imagen 4, aprovechando el mismo flujo de trabajo de Firebase AI Logic.
Configuración del modelo de imágenes
Además del modelo de texto, Firebase AI Logic permite generar imágenes con Imagen 4.
const modelImage = getImagenModel(ai, {
model: 'imagen-4.0-generate-001',
generationConfig: {
aspectRatio: ImagenAspectRatio.SQUARE,
imageFormat: ImagenImageFormat.jpeg(100),
numberOfImages: 1
}
});
Con esta configuración, le indicamos al modelo que queremos una imagen de aspecto 1:1, que la calidad de compresión sea de 100 y que solo se genere una imagen.
Creando el servicio GenAiService
Finalmente, encapsulamos toda la lógica en un servicio Angular para poder inyectarlo fácilmente en cualquier componente.
export class GenAiService {
const LIST_FOOD_BY_INGREDIENTS_PROMPT = (payload: { ingredient: string; quantity_people: number }) => `
Eres el asistente de inteligencia artificial más conocedor del rubro gastronómico en el Perú.
Genere un lista de 4 recetas peruanas o similares para una persona que quiere alimentarse de forma saludable.
Las recetas deben incluir los siguientes ingredientes: ${payload.ingredient}.
En la matriz del las recetas, coloque las recetas como lo haría un recetario de comida.
Dé a cada receta una descripción únicos.
Las recetas deben ser saludables y equilibradas.
Además que sean para ${payload.quantity_people} personas.
Las recetas tiene que estar en español.
La descripción de cada receta debe detallar el plato y si está inspirado en alguna cocina.
`;
const GENERATE_IMAGE_FOOD_PROMPT = (name: string) => `
Genera una imagen de un plato de comida saludable llamado ${name}.
`;
// Generate recipes based on one ingredient and number of people
async getRecipesByIngredients(payload: { ingredient: string; quantity_people: number }) {
const result = await model.generateContent(LIST_FOOD_BY_INGREDIENTS_PROMPT(payload));
const response = result.response;
const recipesData = JSON.parse(response.text());
return recipesData;
}
// Create an image of the food
async generatedImageFood(payload: { food: string }) {
const result = await modelImage.generateImages(GENERATE_IMAGE_FOOD_PROMPT(payload.food));
const image = result.images[0];
return image;
}
}
Aquí se ve el poder de Firebase AI Logic: no necesitas manejar API keys ni endpoints de Google Cloud. El SDK se encarga de la autenticación, ejecución y formato de respuesta automáticamente.
Ya con el servicio configurado, el siguiente paso es usarlo dentro de un componente y conectar la interfaz con la generación de contenido.
Usando el servicio desde el componente Angular
Ahora que tenemos el servicio listo, podemos llamarlo directamente desde nuestro componente.
generateRecipesByIngredient() {
this.isLoading = true;
this.listFood = [];
const payload = {
ingredient: this.formSearch.value.ingredient,
quantity_people: 2
}
this.genAI.getRecipesByIngredients(payload).then((data) => {
this.listFood = data["recipes"];
this.isLoading = false;
});
}
generatedImageFood(name) {
const payload = {food: name}
this.genAI.generatedImageFood(payload).then((data) => {
this.detailFood.image = data.bytesBase64Encoded;
});
}
}
generateRecipesByIngredient()envía un prompt al modelo Gemini para generar recetas según el ingrediente indicado. Las respuestas del modelo llegan estructuradas y seguras gracias al esquemaresponseSchemadefinido antes.generatedImageFood()usa el modeloImagen 4para crear la imagen del plato.

Con esto completamos una integración funcional de Firebase AI Logic en una app Angular, desde la configuración inicial hasta el consumo directo en el componente.
Puedes explorar el código completo del proyecto en GitHub: lperezp/food-fit-app (feature/add-ai-logic).
Incluye todo el código mostrado en este artículo, junto con una pequeña interfaz en Angular para generar recetas e imágenes con Gemini.
Este primer ejemplo demuestra lo simple que puede ser llevar IA generativa a tu frontend. Si estás experimentando con Gemini, Firebase AI Logic es el punto de partida ideal para prototipar ideas sin fricción.
En la próxima parte, veremos cómo reforzar la seguridad con App Check y cómo aprovechar la monitorización para entender el uso real de los modelos en tu app.