Beta: Firebase Genkit is in Beta, which means that it is not subject to any SLA or deprecation policy and could change in backwards-incompatible ways. Throughout the Beta period, Firebase Genkit and its documentation will be updated and improved.

Se usó la API de Cloud Translation para traducir esta página.

Genkit con Cloud Functions para Firebase

Firebase Genkit incluye un complemento que te ayuda a implementar tus flujos en Firebase Cloud Functions. Esta página, por ejemplo, te guía a través del proceso de e implementar el flujo de muestra predeterminado en Firebase.

Implementa un flujo como una Cloud Function

Instala las herramientas necesarias:
1. Asegúrate de estar usando Node.js 20 o una versión posterior (ejecuta node --version para verificar).
2. Instala Firebase CLI.
Crea un proyecto nuevo de Firebase con Firebase console o selecciona uno existente.

Actualizar el proyecto al plan Blaze, que es necesario para implementar Cloud Cloud Functions.

Accede con Firebase CLI:

firebase login
firebase login --reauth # alternative, if necessary
firebase login --no-localhost # if running in a remote shell

Crea un directorio de proyecto nuevo:

export PROJECT_ROOT=~/tmp/genkit-firebase-project1
mkdir -p $PROJECT_ROOT

Inicializa un proyecto de Firebase con Genkit en la carpeta:
```
cd $PROJECT_ROOT
firebase init genkit
```
- Selecciona el proyecto que creaste anteriormente.
- Selecciona el proveedor de modelos que deseas usar.
Acepta los valores predeterminados para el resto de los mensajes. La herramienta genkit creará algunos archivos fuente de muestra para que empieces a desarrollar tus propios flujos de IA. Para el resto de este instructivo, solo implementarás el flujo de muestra.
Haz que las credenciales de la API estén disponibles para tu Cloud Function. Realiza una de las siguientes acciones según el proveedor de modelos que hayas elegido:
Gemini (IA de Google)
1. Asegúrate de que la IA de Google esté disponible en tu región.
2. Genera una clave de API para la API de Gemini con Google AI Studio.
3. Almacena tu clave de API en Cloud Secret Manager:
```
firebase functions:secrets:set GOOGLE_GENAI_API_KEY
```
  Este paso es importante para evitar que se filtre tu clave de API por accidente. que otorga acceso a un servicio de uso medido.
  
  Consulta Almacena información de configuración sensible y accede a ella para obtener más información sobre la administración de Secrets.
4. Edita src/index.ts y agrega lo siguiente después de las importaciones existentes:
```
import {defineSecret} from "firebase-functions/params";
const googleAIapiKey = defineSecret("GOOGLE_GENAI_API_KEY");
```
  Luego, en la definición del flujo, declara que la Cloud Function necesita acceso a este valor del Secret:
```
export const menuSuggestionFlow = onFlow(
  {
    name: "menuSuggestionFlow",
    // ...
    httpsOptions: {
      secrets: [googleAIapiKey],  // Add this line.
    },
  },
  async (subject) => {
    // ...
  }
);
```
Ahora, cuando implementes esta función, tu clave de API se almacenará en Cloud Secret Manager, y está disponible en Cloud Functions en un entorno de nube.
Gemini (Vertex AI)
1. En la consola de Cloud, Habilita la API de Vertex AI para tu proyecto de Firebase.
2. En la página IAM asegúrate de que la cuenta de servicio de procesamiento predeterminada tiene otorgado el rol de usuario de Vertex AI.
El único secreto que debes configurar para este instructivo es para el proveedor del modelo, pero, en general, debes hacer algo similar para cada servicio que tu flujo use.
Si accederás a tu flujo desde una app web (lo que harás en siguiente sección), en el parámetro httpsOptions, establece una política de CORS:
```
export const menuSuggestionFlow = onFlow(
  {
    name: "menuSuggestionFlow",
    // ...
    httpsOptions: {
      cors: true,  // Add this line.
    },
  },
  async (subject) => {
    // ...
  }
);
```
Es probable que quieras una política más restrictiva para las apps de producción, para este instructivo.
Opcional: Prueba tu flujo en la IU para desarrolladores:
1. Haz que las credenciales de la API estén disponibles de forma local. Realiza una de las siguientes acciones: según el proveedor de modelos que elijas:
  Gemini (IA de Google)
  Establece la variable de entorno GOOGLE_GENAI_API_KEY en tu clave:
```
export GOOGLE_GENAI_API_KEY=<your API key>
```
  Gemini (Vertex AI)
  Configura algunas variables de entorno adicionales y usa el Herramienta gcloud para configurar las credenciales predeterminadas de la aplicación de forma local:
```
export GCLOUD_PROJECT=<your project ID>
export GCLOUD_LOCATION=us-central1
gcloud auth application-default login
```
2. Inicia la IU:
```
cd $PROJECT_ROOT/functions
genkit start
```
3. En la IU del desarrollador (http://localhost:4000/), ejecuta el flujo:
  1. Haz clic en menuSuggestionFlow.
  2. En la pestaña Input JSON, proporciona un asunto para el modelo:
```
"AI app developers"
```
  3. En la pestaña JSON de autenticación, proporciona un objeto auth simulado:
```
{
  "uid": 0,
  "email_verified": true
}
```
  4. Haz clic en Ejecutar.
Si todo funciona como se esperaba hasta ahora, puedes implementar el flujo:
```
cd $PROJECT_ROOT
firebase deploy --only functions
```

Ya implementaste el flujo como una Cloud Function. Sin embargo, no podrás acceder a tu extremo implementado con curl o uno similar, debido a la de Google Cloud. Continúa con la siguiente sección para obtener más información acceder al flujo.

Prueba el flujo implementado

Es fundamental que cada flujo que implementes establezca una política de autorización. Sin uno, tus flujos de IA generativa potencialmente costosos podrían invocarse a nadie.

El flujo de muestra predeterminado tiene una política de autorización como la siguiente:

firebaseAuth((user) => {
  if (!user.email_verified) {
    throw new Error('Verified email required to run flow');
  }
});

Esta política usa el ayudante firebaseAuth() para permitir el acceso solo a usuarios de tu app con direcciones de correo electrónico verificadas. Del lado del cliente, debes configura el encabezado Authorization: Bearer con un token de ID de Firebase que cumpla con tu política. Los SDK de cliente de Cloud Functions proporcionan función que admite llamadas métodos que automatizan esto.

Para probar tu extremo de flujo, implementa el siguiente ejemplo mínimo app:

En la Configuración del proyecto de Firebase console, agregar una nueva app web y seleccionar la opción para configurar Hosting.
En la Autenticación de Firebase console, habilita el proveedor de Google, que se que usaremos en este ejemplo.
En el directorio de tu proyecto, configura Firebase Hosting para realizar la implementación. la app de ejemplo:
```
cd $PROJECT_ROOT
firebase init hosting
```
Acepta los valores predeterminados de todos los mensajes.

Reemplaza public/index.html por lo siguiente:

<!doctype html>
<html>
  <head>
    <title>Genkit demo</title>
  </head>
  <body>
    <div id="signin" hidden>
      <button id="signinBtn">Sign in with Google</button>
    </div>
    <div id="callGenkit" hidden>
      Subject: <input type="text" id="subject" />
      <button id="suggestMenuItem">Suggest a menu theme</button>
      <p id="menuItem"></p>
    </div>
    <script type="module">
      import { initializeApp } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-app.js';
      import {
        getAuth,
        onAuthStateChanged,
        GoogleAuthProvider,
        signInWithPopup,
      } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-auth.js';
      import {
        getFunctions,
        httpsCallable,
      } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-functions.js';

      const firebaseConfig = await fetch('/__/firebase/init.json');
      initializeApp(await firebaseConfig.json());

      async function generateMenuItem() {
        const menuSuggestionFlow = httpsCallable(
          getFunctions(),
          'menuSuggestionFlow'
        );
        const subject = document.querySelector('#subject').value;
        const response = await menuSuggestionFlow(subject);
        document.querySelector('#menuItem').innerText = response.data;
      }

      function signIn() {
        signInWithPopup(getAuth(), new GoogleAuthProvider());
      }

      document
        .querySelector('#signinBtn')
        .addEventListener('click', signIn);
      document
        .querySelector('#suggestMenuItem')
        .addEventListener('click', generateMenuItem);

      const signinEl = document.querySelector('#signin');
      const genkitEl = document.querySelector('#callGenkit');

      onAuthStateChanged(getAuth(), (user) => {
        if (!user) {
          signinEl.hidden = false;
          genkitEl.hidden = true;
        } else {
          signinEl.hidden = true;
          genkitEl.hidden = false;
        }
      });
    </script>
  </body>
</html>

Implementa la app web y la Cloud Function:
```
cd $PROJECT_ROOT
firebase deploy
```

Para abrir la app web, visita la URL impresa por el comando deploy. La app requiere que accedas con una Cuenta de Google, después de lo cual podrás iniciar de extremo a extremo.

Cómo desarrollar con Firebase Local Emulator Suite

Firebase ofrece un paquete de emuladores para el desarrollo local que puedes usar con Genkit.

Para usar Genkit con Firebase Emulator Suite, inicia los emuladores de Firebase de la siguiente manera:

GENKIT_ENV=dev firebase emulators:start --inspect-functions

Esto ejecutará tu código en el emulador y el framework de Genkit en modo de desarrollo, que inicia y expone la API de reflexión de Genkit (pero no la IU para desarrolladores).

Luego, inicia la IU de Genkit Dev con la opción --attach para conectarla al código que se ejecuta en el emulador de Firebase:

genkit start --attach http://localhost:3100 --port 4001

Para ver los seguimientos de Firestore en la IU para desarrolladores, navega a la pestaña Inspeccionar y activa o desactiva “Dev/Prod” interruptor. Cuando se activa la opción “prod” cargará registros de Firestore.