Comienza a usar Genkit con Go (alfa)

Ya está disponible la versión preliminar de las bibliotecas de Firebase Genkit para Go. Debido a que el Actualmente, las bibliotecas de Go están en versión Alfa, es posible que veas cambios en la API y en las funciones como se muestra a continuación: y cómo progresa el desarrollo. Te recomendamos usarlo solo para el prototipado y exploración.

Si detectas problemas con las bibliotecas o con esta documentación, infórmalos en nuestro repositorio de GitHub.

Para comenzar a usar Genkit, instala la CLI y ejecuta genkit init en un proyecto de Go. En el resto de esta página, se muestra cómo hacerlo.

Requisitos

  • Go 1.22 o superior

  • Node.js 20 o una versión posterior (para la IU y la CLI de Genkit)

    Recomendación: Las nvm y Las herramientas nvm-windows son una conveniente de instalar versiones específicas de Node si aún no lo hiciste instalada en tu sistema. Estas herramientas instalan Node por usuario, por lo que no es necesario realizar cambios en todo el sistema.

    Para instalar nvm en un sistema similar a Unix, como macOS o Linux, ejecuta el siguiente comando: :

    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

    Luego, para instalar Node con nvm, abre una shell nueva y ejecuta el siguiente comando: :

    nvm install 20

Procedimiento

  1. Para instalar la CLI de Genkit, ejecuta el siguiente comando:

    npm i -g genkit

    Este comando instala la CLI de Genkit en el directorio de instalación de Node. para que pueda usarse fuera de un proyecto de Node.

  2. Crea un directorio de proyecto nuevo:

    mkdir genkit-intro && cd genkit-intro

  3. Inicializa un proyecto de Genkit:

    genkit init

    1. Selecciona Go como el entorno de ejecución.

    2. Selecciona tu modelo:

      Gemini (IA de Google)

      La forma más sencilla de comenzar es con la API de Gemini de Google AI. Asegúrate de que es disponibles en tu región.

      Genera una clave de API para la la API de Gemini con Google AI Studio. Luego, configura el GOOGLE_GENAI_API_KEY de entorno por tu clave:

      export GOOGLE_GENAI_API_KEY=<your API key>

      Gemini (Vertex AI)

      Si la API de Gemini de Google AI no está disponible en tu región, considera con la API de Vertex AI, que también ofrece Gemini y otros modelos. Tú debe tener un proyecto de Google Cloud con facturación, habilitar Platform y establece algunas variables de entorno adicionales:

      gcloud services enable aiplatform.googleapis.com
export GCLOUD_PROJECT=<your project ID>
export GCLOUD_LOCATION=us-central1

      Consulta los precios de Vertex AI.

    3. Especifica cualquier opción para el nombre del módulo. Por ejemplo: example/genkit-intro.

    4. Elige respuestas predeterminadas para el resto de las preguntas, lo que inicializamos la carpeta de tu proyecto con algún código de muestra.

    El comando genkit init crea un módulo de Go de muestra y, luego, instala el las dependencias requeridas. El archivo main.go contiene un solo flujo. menuSuggestionFlow, que solicita a un LLM que sugiera un elemento para un restaurante con un tema determinado.

    Este archivo se verá de la siguiente manera (los pasos de configuración del complemento podría verse diferente si seleccionaste Vertex AI):

    package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    // Import Genkit and the Google AI plugin
    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googleai"
)

func main() {
    ctx := context.Background()

    // Initialize the Google AI plugin. When you pass nil for the
    // Config parameter, the Google AI plugin will get the API key from the
    // GOOGLE_GENAI_API_KEY environment variable, which is the recommended
    // practice.
    if err := googleai.Init(ctx, nil); err != nil {
        log.Fatal(err)
    }

    // Define a simple flow that prompts an LLM to generate menu suggestions.
    genkit.DefineFlow("menuSuggestionFlow", func(ctx context.Context, input string) (string, error) {
        // The Google AI API provides access to several generative models. Here,
        // we specify gemini-1.5-flash.
        m := googleai.Model("gemini-1.5-flash")
        if m == nil {
            return "", errors.New("menuSuggestionFlow: failed to find model")
        }

        // Construct a request and send it to the model API (Google AI).
        resp, err := m.Generate(ctx,
            ai.NewGenerateRequest(
                &ai.GenerationCommonConfig{Temperature: 1},
                ai.NewUserTextMessage(fmt.Sprintf(`Suggest an item for the menu of a %s themed restaurant`, input))),
            nil)
        if err != nil {
            return "", err
        }

        // Handle the response from the model API. In this sample, we just
        // convert it to a string. but more complicated flows might coerce the
        // response into structured output or chain the response into another
        // LLM call.
        text, err := resp.Text()
        if err != nil {
            return "", fmt.Errorf("menuSuggestionFlow: %v", err)
        }
        return text, nil
    })

    // Initialize Genkit and start a flow server. This call must come last,
    // after all of your plug-in configuration and flow definitions. When you
    // pass a nil configuration to Init, Genkit starts a local flow server,
    // which you can interact with using the developer UI.
    if err := genkit.Init(ctx, nil); err != nil {
        log.Fatal(err)
    }
}

    A medida que desarrolles las funciones basadas en IA de tu app con Genkit, es probable que con varios pasos, como el procesamiento previo de entradas, rápida construcción, integrar fuentes de información externas para generación de aumento de recuperación (RAG) y mucho más.

  4. Ahora puedes ejecutar y explorar de forma local las funciones de Genkit y el proyecto de muestra en tu máquina. Descarga y, luego, inicia la IU para desarrolladores de Genkit:

    genkit start

    Te damos la bienvenida a IU para desarrolladores de Genkit

    La IU para desarrolladores de Genkit ya se está ejecutando en tu máquina. Cuando ejecutas modelos o flujos en el próximo paso, la máquina realizará las tareas de organización necesario para hacer que los pasos de tu flujo funcionen juntos; llamadas a direcciones externas servicios, como la API de Gemini, se seguirán creando con versiones servidores.

    Además, debido a que estás en un entorno de desarrollo, Genkit almacenará seguimientos y del flujo de trabajo en los archivos locales.

  5. La IU para desarrolladores de Genkit se descarga y abre automáticamente cuando ejecutas la Comando genkit start.

    La IU para desarrolladores te permite ver los flujos que definiste y los modelos configurar, ejecutarlos y examinar los seguimientos de ejecuciones anteriores. Prueba algunos de estas funciones:

    • En la pestaña Run, verás una lista de todos los flujos que tienes. definidos y los modelos que hayan configurado los complementos.

      Haz clic en menuSuggestedFlow e intenta ejecutarlo con texto de entrada (para ejemplo, "cat"). Si todo sale bien, recibirás un menú como recompensa para un restaurante con temática gatuna.

    • En la pestaña Inspect, verás un historial de ejecuciones de flujo. Por cada de flujo, puedes ver los parámetros que se pasaron al flujo y un seguimiento de cada paso a medida que se ejecutaban.