Anuncio de Genkit Go 1.0 y el desarrollo asistido por IA mejorado

9 DE SEPTIEMBRE DE 2025
Chris Gill Product Manager
Cameron Balahan Group Product Manager

Nos complace anunciar el lanzamiento de Genkit Go 1.0, la primera versión estable y lista para la producción del framework de desarrollo de IA de código abierto de Google para el ecosistema Go. Junto con esta versión, también presentamos el comando genkit init: ai-tools para potenciar tu flujo de trabajo de desarrollo asistido por IA.

Genkit es un framework de código abierto para crear aplicaciones de pila completa impulsadas por IA. Proporciona una interfaz unificada para múltiples proveedores de modelos y APIs optimizadas para contenido multimodal, salidas estructuradas, llamadas a herramientas, generación aumentada de recuperación (RAG) y flujos de trabajo agénticos. Con Genkit Go, ahora puedes compilar e implementar aplicaciones de IA listas para la producción con la velocidad, la seguridad y la confiabilidad de Go.

TL;DR

Genkit Go ahora es estable y ya se puede usar para la producción.

Características principales:

  • Flujos de IA de tipo seguro con estructuras Go y validación de esquemas JSON
  • Interfaz de modelo unificado compatible con Google AI, Vertex AI, OpenAI, Ollama y más
  • Llamadas de herramientas, RAG y compatibilidad multimodal
  • Herramientas de desarrollo local enriquecidas con un binario CLI independiente y una interfaz de usuario de desarrollador
  • Integración del asistente de codificación de IA a través del comando genkit init:ai-tools para herramientas como la CLI de Gemini

¿Todo listo para empezar a codificar? Consulta nuestra guía de inicio.

Novedades de Genkit Go 1.0

Listo para la producción

Genkit Go 1.0 representa nuestro compromiso de proporcionar una base estable y confiable para crear aplicaciones impulsadas por IA en Go. Con esta versión, puedes implementar en producción aplicaciones impulsadas por IA con Genkit, sabiendo que la API es estable y está probada.

Tal como ocurre con Go, se pretende que los programas escritos con Genkit 1.* continúen compilándose y ejecutándose correctamente, sin cambios, incluso cuando surjan futuras versiones “de puntos” de Genkit (Genkit 1.1, Genkit 1.2, etc.).

Flujos de IA de tipo seguro

Una de las características más potentes de Genkit son los flujos, funciones para casos de uso de IA que proporcionan observabilidad, pruebas fáciles e implementación simplificada. Así es como puedes definir un flujo en Go para generar recetas estructuradas:

package main
 
import (
    "context"
    "encoding/json"
    "fmt"
    "log"
 
    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)
 
// Define your data structures
type RecipeInput struct {
    Ingredient          string `json:"ingredient" jsonschema:"description=Main ingredient or cuisine type"`
    DietaryRestrictions string `json:"dietaryRestrictions,omitempty" jsonschema:"description=Any dietary restrictions"`
}
 
type Recipe struct {
    Title        string   `json:"title"`
    Description  string   `json:"description"`
    PrepTime     string   `json:"prepTime"`
    CookTime     string   `json:"cookTime"`
    Servings     int      `json:"servings"`
    Ingredients  []string `json:"ingredients"`
    Instructions []string `json:"instructions"`
    Tips         []string `json:"tips,omitempty"`
}
 
func main() {
    ctx := context.Background()
 
    // Initialize Genkit with plugins
    g := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-2.5-flash"),
    )
 
    // Define a type-safe flow
    recipeFlow := genkit.DefineFlow(g, "recipeGeneratorFlow", 
        func(ctx context.Context, input *RecipeInput) (*Recipe, error) {
            dietaryRestrictions := input.DietaryRestrictions
            if dietaryRestrictions == "" {
                dietaryRestrictions = "none"
            }
 
            prompt := fmt.Sprintf(`Create a recipe with the following requirements:
                Main ingredient: %s
                Dietary restrictions: %s`, input.Ingredient, dietaryRestrictions)
 
            // Generate structured data with type safety
            recipe, _, err := genkit.GenerateData[Recipe](ctx, g,
                ai.WithPrompt(prompt),
            )
            if err != nil {
                return nil, fmt.Errorf("failed to generate recipe: %w", err)
            }
 
            return recipe, nil
        })
 
    // Run the flow
    recipe, err := recipeFlow.Run(ctx, &RecipeInput{
        Ingredient:          "avocado",
        DietaryRestrictions: "vegetarian",
    })
    if err != nil {
        log.Fatalf("could not generate recipe: %v", err)
    }
 
    // Print the structured recipe
    recipeJSON, _ := json.MarshalIndent(recipe, "", "  ")
    fmt.Println("Sample recipe generated:")
    fmt.Println(string(recipeJSON))
 
    <-ctx.Done() // Used for local testing only
}
Go

Interfaz de modelo unificado

Genkit Go proporciona una interfaz única y coherente para trabajar con múltiples proveedores de modelos de IA, incluidos Google AI, Vertex AI, OpenAI, Anthropic y Ollama. Más información sobre la generación de contenido con modelos de IA:

// Use Google AI models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.5-flash"),
    ai.WithPrompt("What is the weather like today?"),
)
 
// Use OpenAI models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("openai/gpt-4o"),
    ai.WithPrompt("How are you today?"),
)
 
// Switch to Ollama for local models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("ollama/llama3"),
    ai.WithPrompt("What is the meaning of life?"),
)
Go

Llamadas de herramientas

Genkit Go facilita el acceso de tus modelos de IA a funciones externas y APIs. Consulta la guía completa de llamadas de herramientas:

// Define a tool
type WeatherInput struct {
    Location string `json:"location" jsonschema_description:"Location to get weather for"`
}
 
getWeatherTool := genkit.DefineTool(g, "getWeather", 
    "Gets the current weather in a given location",
    func(ctx *ai.ToolContext, input WeatherInput) (string, error) {
        // Your weather API logic here
        return fmt.Sprintf("The current weather in %s is 72°F and sunny.", input.Location), nil
    })
 
// Use the tool in generation
resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("What's the weather in San Francisco?"),
    ai.WithTools(getWeatherTool),
)
Go

Fácil implementación

Implementa tus flujos como extremos HTTP con una configuración mínima. Consulta las guías de implementación para obtener más opciones:

// Create HTTP handlers for your flows
mux := http.NewServeMux()
mux.HandleFunc("POST /recipeGeneratorFlow", genkit.Handler(recipeFlow))
 
// Start the server
log.Fatal(server.Start(ctx, "127.0.0.1:3400", mux))
Go

Herramientas enriquecidas para desarrolladores

Genkit Go incluye un conjunto completo de herramientas de desarrollo diseñadas para hacer que la creación de aplicaciones de IA sea rápida e intuitiva. Toda la cadena de herramientas local está disponible a través de una única CLI que funciona a la perfección con tu flujo de trabajo de desarrollo de Go.

Instalación de CLI independiente

Comienza rápidamente con nuestro binario CLI independiente (no se requieren otras instalaciones de tiempo de ejecución):

Para macOS y Linux:

curl -sL cli.genkit.dev | bash
Shell

Para Windows: descargar directamente de cli.genkit.dev

La CLI funciona con aplicaciones Genkit en cualquier lenguaje compatible (JavaScript, Go, Python) y te proporciona varios comandos convenientes para probar e iterar rápidamente, como ejecutar y evaluar tus flujos.

Interfaz de usuario para desarrolladores interactiva

La IU para desarrolladores proporciona una interfaz visual para probar y depurar tus aplicaciones con IA:

  • Prueba flujos de forma interactiva. Ejecuta flujos con diferentes entradas y consulta los resultados renderizados de forma clara.
  • Depura con rastreo detallado. Visualiza exactamente lo que tus flujos de IA están haciendo paso a paso.
  • Supervisa el rendimiento. Realiza un seguimiento de la latencia, el uso de tokens y los costos.
  • Experimenta con indicaciones. Prueba diferentes indicaciones y configuraciones de modelos.

Inicia la interfaz de usuario para desarrolladores junto con tu aplicación Go a través de la CLI:

genkit start -- go run .
Shell

Así es como se ve la experiencia al ejecutar e inspeccionar el flujo de recipeGenerator desde antes:

Presentamos genkit init:ai-tools

También nos complace presentar el comando genkit init:ai-tools, que revoluciona la forma en que trabajas con los asistentes de IA durante el desarrollo. Esta función, ahora disponible para los desarrolladores de JavaScript y Go, configura automáticamente los populares asistentes de codificación de IA para que funcionen sin problemas con el framework y las herramientas de Genkit. Puedes obtener más información sobre el desarrollo asistido por IA en Genkit.

Para usarlo, instala la CLI de Genkit y ejecuta:

genkit init:ai-tools
Shell

Ejecutar el comando hace lo siguiente:

  1. Detecta las configuraciones existentes del asistente de IA y conserva la configuración actual.
  2. Instala el servidor MCP de Genkit con potentes herramientas de desarrollo:
    • lookup_genkit_docs: Busca documentación de Genkit en genkit.dev.
    • list_flows: Enumera todos los flujos en tu aplicación actual de Genkit.
    • run_flow: Ejecuta flujos con entradas de prueba.
    • get_trace: Obtén trazas de ejecución para depuración y análisis.
  1. Crea un archivo GENKIT.md con instrucciones completas específicas del idioma para los asistentes de IA.

Herramientas de IA compatibles

El comando tiene soporte incorporado para lo siguiente:

  • CLI de Gemini, el asistente de codificación de IA basado en CLI de Google
  • Firebase Studio, el entorno de desarrollo ágil y basado en la nube de Firebase
  • Claude Code, el asistente de codificación de Anthropic
  • Cursor, un editor de código impulsado por IA

Para ver otras herramientas, selecciona la opción "genérico" a fin de obtener un archivo GENKIT.md que puedes integrar manualmente.

Experiencia de desarrollo mejorada

Con la integración del asistente de IA, puedes:

  • Hacer preguntas sobre las APIs de Genkit Go y obtener respuestas precisas y actualizadas
  • Generar código Genkit específico de Go que siga las prácticas recomendadas
  • Depurar flujos haciendo que tu asistente de IA analice rastros
  • Probar tus aplicaciones con entradas generadas por IA
  • Obtener ayuda con los patrones específicos de Go y el código idiomático

Inicio rápido

1. Crea un proyecto nuevo:

mkdir my-genkit-app && cd my-genkit-app
go mod init example/my-genkit-app
Shell

2. Instala Genkit y la CLI:

go get github.com/firebase/genkit/go
curl -sL cli.genkit.dev | bash
Shell

3. Configura la integración del asistente de IA:

genkit init:ai-tools
Shell

4. Crea tu primer flujo con los ejemplos anteriores.

5. Inicia la interfaz de usuario para desarrolladores:

genkit start -- go run .
Shell

Para obtener una explicación más detallada, consulta la guía de inicio.

Más información

Genkit Go 1.0 combina el rendimiento y la confiabilidad de Go con el framework y las herramientas de IA listos para la producción de Genkit. ¡Ya queremos ver lo que creas!

¡Feliz codificación! 🚀