AI Application Development with Genkit

firebase/genkit

Genkit isn't just another library; it's a complete framework designed to streamline the entire AI application development lifecycle. Here’s why it's so useful

Familiar Development Flow
As engineers, we're used to writing code, defining functions, and composing them to build a larger system. Genkit uses this exact approach. You define Genkit flows, which are essentially sequences of AI models and tools. This makes the code readable, maintainable, and easy to debug, just like any other part of your application.

Provider Agnostic
You're not locked into a single AI model or platform. Genkit allows you to work with a wide range of models from providers like Google (Vertex AI, Google AI Studio), OpenAI, and more. This flexibility means you can choose the best model for a specific task without having to rewrite your entire application.

Built-in Observability
This is a huge win. When you run a Genkit flow, it automatically logs the steps, inputs, and outputs. You can visualize the entire flow, inspect the data at each step, and pinpoint exactly where things are going wrong. This kind of built-in tracing is a lifesaver for debugging complex AI systems.

Evaluation and Testing
How do you know if your AI feature is actually good? Genkit provides tools for evaluation. You can define a test suite with specific prompts and expected outputs, and then run an evaluation to see how well your AI flow performs. This is crucial for ensuring quality and making data-driven decisions about model changes.

Easy Integration
Genkit is designed to be easily integrated into your existing application. It runs locally for development but can be deployed to cloud environments like Google Cloud Functions, making it simple to get your AI features into production.

Let's walk through how you'd get started with Genkit.

First, you'll need to set up your environment. Genkit is a Node.js framework, so make sure you have Node.js installed. Then, you can install the Genkit CLI globally

npm install -g genkitx

Next, initialize a new Genkit project in a new directory

genkitx init

This will set up a basic project structure with a src/index.ts file, a package.json, and other necessary files.

A Genkit flow is the core concept. It's a function that defines a sequence of steps. Let's create a simple flow that takes a user query and generates a response using a large language model (LLM).

Here’s an example using a hypothetical model provider.

import * as genkit from 'genkit';
import { defineFlow, generate } from 'genkit/core';
import { googleAI } from 'genkit/providers/google-ai'; // Or any other provider

// Configure Genkit
genkit.configure({
  plugins: [
    googleAI({ apiKey: process.env.GOOGLE_API_KEY }),
  ],
  // ... other configurations
});

// Define a simple AI flow
export const simpleFlow = defineFlow({
  name: 'simpleFlow',
  inputSchema: {
    type: 'string'
  },
  outputSchema: {
    type: 'string'
  },
}, async (input) => {
  const llmResponse = await generate({
    model: 'google-ai-model-name', // Use the name of your specific model
    prompt: `The user wants to know about: ${input}. Provide a concise and helpful answer.`
  });

  return llmResponse.text();
});

In this code

We use defineFlow to create a new flow called simpleFlow.

The inputSchema and outputSchema define the expected data types for the input and output.

Inside the flow, we use the generate function, which is a key primitive in Genkit. It interacts with the configured AI model.

The model parameter specifies which model to use from the configured providers.

The prompt is the instruction we give to the AI.

Genkit comes with a developer UI that is incredibly helpful. You can start it from your project directory

genkitx start

This command launches a local web server with a UI. From there, you can

View your defined flows
You'll see simpleFlow listed.

Test your flows
You can provide an input to simpleFlow and see the output directly in the UI.

Inspect runs
When you run a flow, the UI shows a detailed trace of the execution, including the inputs and outputs of each step. This makes debugging a breeze.

Genkit shines when you need to compose multiple steps. Let’s imagine we want to build a flow that takes a user's question about an image and an image URL, then uses an LLM to answer.

import * as genkit from 'genkit';
import { defineFlow, generate, ask } from 'genkit/core';
import { googleAI } from 'genkit/providers/google-ai';
import { text, image, multiPart, multiImage } from 'genkit/core/prebuilt';

// Configure the model
genkit.configure({
  plugins: [
    googleAI({ apiKey: process.env.GOOGLE_API_KEY }),
  ],
});

export const imageQA = defineFlow(
  {
    name: 'imageQA',
    inputSchema: {
      question: text(),
      imageUrl: text(),
    },
    outputSchema: text(),
  },
  async ({ question, imageUrl }) => {
    // 1. Describe the image using a multi-modal model
    const imageDescription = await generate({
      model: 'google-ai-multimodal-model',
      prompt: multiPart(
        image(imageUrl),
        text(`Describe the key features of the image.`)
      ),
    });

    // 2. Use the description and the original question to get a final answer
    const finalAnswer = await generate({
      model: 'google-ai-model-name',
      prompt: `Based on this description: "${imageDescription.text()}", answer the following question: "${question}"`
    });

    return finalAnswer.text();
  }
);

In this more advanced example

We define a flow called imageQA that takes a question and an imageUrl.

We use a chaining pattern. The first generate call uses a multimodal model to get a description of the image.

The result of the first step (imageDescription.text()) is then used as part of the prompt for the second generate call, which uses a different model to formulate the final answer.

Genkit's dev UI would let you see both of these generate calls as separate steps, making it very easy to see the intermediate outputs.