Temos o prazer de anunciar o lançamento do Genkit Go 1.0, a primeira versão estável e pronta para produção do framework de desenvolvimento de IA de código aberto do Google para o ecossistema Go. Junto com esta versão, também estamos introduzindo o comando genkit init:ai-tools para turbinar seu fluxo de trabalho de desenvolvimento assistido por IA.
O Genkit é um framework de código aberto para a criação de aplicativos habilitados por IA de pilha completa. Ele fornece uma interface unificada para vários provedores de modelos e APIs otimizadas para conteúdo multimodal, saídas estruturadas, chamadas de ferramentas, geração aumentada de recuperação (RAG, na sigla em inglês) e fluxos de trabalho agênticos. Com o Genkit Go, agora você pode criar e implantar aplicativos de IA prontos para produção com a velocidade, a segurança e a confiabilidade do Go.
O Genkit Go está na versão estável e pronto para uso em produção!
Principais recursos:
Quer começar a codificar? Confira nosso guia de primeiros passos.
O Genkit Go 1.0 representa nosso compromisso de fornecer uma base estável e confiável para a criação de aplicativos habilitados por IA no Go. Com esta versão, você pode implantar aplicativos habilitados por IA em produção com o Genkit com a certeza de uma API estável e bem testada.
Assim como no próprio Go, o objetivo é que os programas escritos com o Genkit 1.* continuem a ser compilados e executados corretamente sem alterações, mesmo que surjam futuras versões "pontuais" do Genkit (Genkit 1.1, Genkit 1.2 etc.).
Entre os recursos mais avançados do Genkit estão os fluxos: funções para casos de uso de IA que oferecem observabilidade, testes fáceis e implantação simplificada. Veja como você pode definir um fluxo no Go para gerar receitas estruturadas:
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
}O Genkit Go fornece uma interface única e consistente para trabalhar com vários provedores de modelos de IA, incluindo Google AI, Vertex AI, OpenAI, Anthropic e Ollama. Saiba mais sobre como gerar conteúdo com 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?"),
)Com o Genkit Go, você pode facilitar o acesso de seus modelos de IA a APIs e funções externas. Consulte o guia completo sobre chamadas de ferramentas:
// 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),
)Implante fluxos como endpoints HTTP com o mínimo de configuração. Consulte os guias de implantação para ver mais opções:
// 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))O Genkit Go inclui um conjunto abrangente de ferramentas de desenvolvimento projetadas para tornar a criação de aplicativos de IA rápida e intuitiva. Toda a cadeia de ferramentas local está disponível por meio de uma única CLI que funciona perfeitamente com seu fluxo de trabalho de desenvolvimento Go.
Comece rapidamente com nosso binário CLI autônomo, sem necessidade de nenhuma outra instalação de ambiente de execução:
Para macOS e Linux:
curl -sL cli.genkit.dev | bashPara Windows: faça o download diretamente em: cli.genkit.dev
A CLI funciona com aplicativos Genkit em qualquer linguagem com suporte (JavaScript, Go, Python) e fornece vários comandos convenientes para testes e iterações rápidos, como execução e avaliação de fluxos.
A IU para desenvolvedores fornece uma interface visual para testes e depuração de aplicativos de IA:
Inicie a IU para desenvolvedores juntamente com o aplicativo Go via CLI:
genkit start -- go run .Veja abaixo como é a experiência de execução e inspeção do fluxo recipeGenerator mostrado acima:
Também estamos empolgados com a introdução do comando genkit init:ai-tools, que revoluciona a forma como você trabalha com assistentes de IA durante o desenvolvimento. Esse recurso, já disponível para desenvolvedores JavaScript e Go, configura automaticamente assistentes populares de codificação de IA para funcionarem de maneira integrada ao framework e às ferramentas do Genkit. Saiba mais sobre o desenvolvimento assistido por IA no Genkit.
Para utilizá-lo, instale a CLI do Genkit e execute:
genkit init:ai-toolsA execução do comando faz o seguinte:
O comando tem suporte incorporado ao seguinte:
Para outras ferramentas, selecione a opção "generic" para obter um arquivo GENKIT.md para integração manual.
Com a integração a assistentes de IA, você pode:
1. Crie um novo projeto:
mkdir my-genkit-app && cd my-genkit-app
go mod init example/my-genkit-app2. Instale o Genkit e a CLI:
go get github.com/firebase/genkit/go
curl -sL cli.genkit.dev | bash3. Configure a integração ao assistente de IA:
genkit init:ai-tools4. Crie seu primeiro fluxo usando os exemplos acima.
5. Inicie a IU para desenvolvedores:
genkit start -- go run .Para ver um tutorial mais detalhado, consulte o guia de primeiros passos.
O Genkit Go 1.0 combina o desempenho e a confiabilidade do Go com o framework e as ferramentas de IA prontas para produção do Genkit. Mal podemos esperar para ver o que você vai criar!
Boa codificação! 🚀
