Forem: CrossPostr

Implementing Automatic LLM Provider Fallback In AI Agents Using an LLM Gateway (OpenAI, Anthropic, Gemini & Bifrost)

Bonnie — Thu, 02 Apr 2026 14:22:18 +0000

Every major LLM provider such as OpenAI, Anthropic, Gemini e.t.c, has experienced outages or rate-limiting incidents in the last twelve months.

As a developer, shipping AI-powered applications or AI agents depending on a single LLM provider is a production risk you cannot afford.

For that reason, you need to implement automatic LLM provider fallback in your app where AI requests are routed to backup LLM providers ( e.g, Anthropic or Gemini) the moment your primary provider (e.g, OpenAI) hits a rate limit, outage, or network error.

In this guide, you will learn how to implement automatic LLM provider fallback using the Bifrost LLM Gateway

Before we jump in, here is what we will be covering:

What is LLM provider fallback (and why it matters in production)?
How to set up Bifrost LLM gateway with multiple providers
How to configure automatic LLM provider failover
Testing LLM fallback with the Bifrost Mocker plugin

What is automatic LLM provider fallback?

LLM provider fallback (also called LLM provider failover) is the practice of automatically routing AI requests to backup providers when your primary provider encounters issues such as rate limiting, network errors, or outages.

Without a fallback strategy, a single provider incident can bring down your entire AI app hence frustrating users and eroding trust. With it, your application continues working transparently, as if nothing went wrong.

To implement automatic LLM provider failover, you can use an LLM gateway such as Bifrost. When your primary AI provider fails, Bifrost automatically tries backup providers in the order you specify using this process:

Primary attempt — Bifrost tries your configured primary provider and model first.
Automatic detection — If the primary fails, Bifrost detects the failure immediately.
Sequential fallbacks — Bifrost tries each fallback provider in order until one succeeds.
Success response — The response from the first successful provider is returned.
Complete failure — If all providers fail, Bifrost returns the original error from the primary provider.

You can read more about how fallbacks work in the Bifrost docs.

Prerequisites

Before we start, make sure you have the following:

Node.js 18+ (for running Bifrost via npx) or Docker (for containerized deployment)
API keys for the providers you want to use:
- OpenAI: platform.openai.com
- Anthropic: console.anthropic.com
- Google (Gemini): aistudio.google.com or Google Cloud (for Vertex)
Python 3.9+ or Node.js for writing the agent code
Go 1.21+ for automatic LLM provider failover demo using Bifrost Mocker plugin

Setting up and configuring LLM providers with Bifrost

In this section, you will how to set up Bifrost LLM gateway with multiple AI model providers that you can use with Claude Code.

Let’s get started.

Step 1: Install Bifrost using NPX binary

To install Bifrost, first, create your project folder named automatic-failover-demo and open it using your preferred code editor such as VS Code or Cursor.

Then run the command below with the **-app-dir** flag that determines where Bifrost stores all its data:

npx -y @maximhq/bifrost -app-dir ./my-bifrost-data

Step 2: Create a config.json file

Once you have installed Bifrost in your project, create a config.json file in the ./my-bifrost-data folder. Then add the code below that defines multiple LLM providers and database persistence.

{
  "$schema": "https://www.getbifrost.ai/schema",
  "client": {
    "enable_logging": true,
    "disable_content_logging": false,
    "drop_excess_requests": false,
    "initial_pool_size": 300,
    "allow_direct_keys": false
  },
  "providers": {
    "openai": {
      "keys": [
        {
          "name": "openai-primary",
          "value": "env.OPENAI_API_KEY",
          "models": [],
          "weight": 1.0
        }
      ]
    },
    "anthropic": {
      "keys": [
        {
          "name": "anthropic-primary",
          "value": "env.ANTHROPIC_API_KEY",
          "models": [],
          "weight": 1.0
        }
      ]
    },
    "gemini": {
      "keys": [
        {
          "name": "gemini-primary",
          "value": "env.GEMINI_API_KEY",
          "models": [],
          "weight": 1.0
        }
      ]
    }
  },
  "config_store": {
    "enabled": true,
    "type": "sqlite",
    "config": {
      "path": "./config.db"
    }
  },
  "logs_store": {
    "enabled": true,
    "type": "sqlite",
    "config": {
      "path": "./logs.db"
    }
  }
}

Step 3: Set up your API keys

After creating the config.json file, set your API keys as environment variables so they're never hardcoded using the commands below in the terminal.

export OPENAI_API_KEY="your-openai-api-key"
export ANTHROPIC_API_KEY="your-anthropic-api-key"
export GEMINI_API_KEY="your-gemini-api-key"

Step 4: Start Bifrost Gateway server

Once you have set up your API keys, start the Bifrost LLM gateway server by running the command below again (Make sure to stop the initial running server instance).

npx -y @maximhq/bifrost -app-dir ./my-bifrost-data

Then Bifrost will listen on port 8080, as shown below.

Finally, navigate to the gateway dashboard at http://localhost:8080 as shown below

Step 5: Verify the Setup

After installing and starting Bifrost, you can verify if it's working by running the curl command below in the terminal.

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Then you should get a response from the Bifrost LLM gateway, as shown below.

How to configure automatic LLM provider failover

To implement automatic LLM provider failover, add fallbacks array to the request payload, as shown below:

curl -X POST http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o-mini",
    "messages": [
      {
        "role": "user",
        "content": "Explain what is an LLM gateway in simple terms"
      }
    ],
    "fallbacks": [
      "anthropic/claude-3-5-sonnet-20241022",
      "openrouter/anthropic.claude-3-sonnet-20240229-v1:0"
    ],
    "max_tokens": 1000,
    "temperature": 0.7
  }'

Bifrost will attempt OpenAI first. If that fails, it will try Anthropic. If Anthropic also fails, it will try Openrouter. The first successful response is returned.

After sending the request, the response format returned is a standard OpenAI-compatible JSON with an extra_fields object that tells you which provider actually handled the request, a shown below.

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "An LLM gateway is a proxy layer that sits between your application and multiple AI providers..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 42,
    "total_tokens": 60
  },
  "extra_fields": {
    "provider": "anthropic",
    "latency": 1.34
  }
}

If extra_fields.provider is "anthropic" and you sent to "openai/gpt-4o-mini", you know a fallback was triggered.

Implementing automatic LLM provider fallback using Bifrost Mocker plugin

Bifrost triggers LLM provider fallback when it detects any of the following:

Network connectivity issues
Provider API errors (HTTP 500, 502, 503, 504)
Rate limiting (HTTP 429 errors)
Model unavailability
Request timeouts
Authentication failures

Rather than waiting for a real outage, you can use the Bifrost Mocker plugin to simulate these failure conditions and verify that your fallback chain works as expected.

In this section, we will mock a rate-limiting error to confirm that Bifrost automatically falls back from OpenAI to Anthropic.

Let’s get started!

Step 1: Initialize the Go Project

Start by creating a new directory for your project and initializing a Go module:

mkdir bifrost-fallback-demo
cd bifrost-fallback-demo
go mod init bifrost-fallback-demo

Step 2: Install Dependencies

After initializing the Go project, install the core Bifrost SDK and the Mocker plugin using the commands below:

go get github.com/maximhq/bifrost/core
go get github.com/maximhq/bifrost/plugins/mocker

Step 3: Set your API keys

Once you have installed the dependencies, set your LLM provider API keys as environment variables:

export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."

Step 4: Configure the Bifrost Account Interface

After setting your API keys, create a file named account.go that implements the schemas.Account interface required by Bifrost to know which providers are available and how to authenticate them, as shown below.

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/maximhq/bifrost/core/schemas"
)

// MyAccount implements the schemas.Account interface with support
// for OpenAI (primary) and Anthropic (fallback) providers.
type MyAccount struct{}

// GetConfiguredProviders returns the list of AI providers this account supports.
// Step 1: Define the providers we want to configure for fallback logic.
func (a *MyAccount) GetConfiguredProviders() ([]schemas.ModelProvider, error) {
    // The order doesn't dictate fallback order here, but it lists all available providers.
    return []schemas.ModelProvider{
        schemas.OpenAI,
        schemas.Anthropic,
    }, nil
}

// GetKeysForProvider returns API keys for the given provider from env vars.
// Step 2: Implement key retrieval for each configured provider.
func (a *MyAccount) GetKeysForProvider(ctx context.Context, provider schemas.ModelProvider) ([]schemas.Key, error) {
    // Step 2a: Setup routing based on the requested provider.
    switch provider {
    case schemas.OpenAI:
        // Step 2b: Retrieve the OpenAI key from the environment.
        key := os.Getenv("OPENAI_API_KEY")
        if key == "" {
            return nil, fmt.Errorf("OPENAI_API_KEY environment variable is not set")
        }
        // Step 2c: Return the configured key.
        // The Weight controls how traffic is routed if multiple keys are present.
        return []schemas.Key{{
            Value:  *schemas.NewEnvVar(key),
            Models: []string{}, // Empty = all models
            Weight: 1.0,
        }}, nil

    case schemas.Anthropic:
        // Step 2d: Retrieve the Anthropic key from the environment.
        key := os.Getenv("ANTHROPIC_API_KEY")
        if key == "" {
            return nil, fmt.Errorf("ANTHROPIC_API_KEY environment variable is not set")
        }
        // Step 2e: Return the Anthropic key with identical configuration format.
        return []schemas.Key{{
            Value:  *schemas.NewEnvVar(key),
            Models: []string{}, // Empty = all models
            Weight: 1.0,
        }}, nil

    default:
        // Step 2f: Handle unconfigured providers gracefully with an error.
        return nil, fmt.Errorf("provider %s not supported", provider)
    }
}

// GetConfigForProvider returns provider-specific network and concurrency config.
// Step 3: Define connection parameters (like rate limits and timeouts) for each provider.
func (a *MyAccount) GetConfigForProvider(provider schemas.ModelProvider) (*schemas.ProviderConfig, error) {
    // Step 3a: Apply configuration to supported providers.
    switch provider {
    case schemas.OpenAI, schemas.Anthropic:
        // Step 3b: Return the default Bifrost network and concurrency settings 
        // for both OpenAI and Anthropic to simplify the setup.
        return &schemas.ProviderConfig{
            NetworkConfig:            schemas.DefaultNetworkConfig,
            ConcurrencyAndBufferSize: schemas.DefaultConcurrencyAndBufferSize,
        }, nil
    default:
        // Step 3c: Reject unsupported providers.
        return nil, fmt.Errorf("provider %s not supported", provider)
    }
}

Step 5: Configure Bifrost Chat Request

Once you have configured the Bifrost account interface, create a main.go file with a helper function that builds a schemas.BifrostChatRequest. The chat request configures the request to target your primary provider (OpenAI) and explicitly define the fallback chain (Anthropic), as shown below:

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    bifrost "github.com/maximhq/bifrost/core"
    "github.com/maximhq/bifrost/core/schemas"
    mocker "github.com/maximhq/bifrost/plugins/mocker"
)

// --- Pointer helpers ---

func stringPtr(s string) *string { return &s }
func boolPtr(b bool) *bool       { return &b }
func intPtr(i int) *int           { return &i }

// buildChatRequest creates a standard chat request targeting OpenAI
// with Anthropic as the fallback provider.
// Step 1: Define the chat request with OpenAI as primary and Anthropic as a fallback.
func buildChatRequest(message string) *schemas.BifrostChatRequest {
    return &schemas.BifrostChatRequest{
        Provider: schemas.OpenAI,
        Model:    "gpt-4o-mini",
        Input: []schemas.ChatMessage{
            {
                Role: schemas.ChatMessageRoleUser,
                Content: &schemas.ChatMessageContent{
                    ContentStr: schemas.Ptr(message),
                },
            },
        },
        // Fallback chain: OpenAI → Anthropic
        Fallbacks: []schemas.Fallback{
            {
                Provider: schemas.Anthropic,
                Model:    "claude-sonnet-4-5-20250929",
            },
        },
        Params: &schemas.ChatParameters{
            MaxCompletionTokens: bifrost.Ptr(200),
            Temperature:         bifrost.Ptr(0.7),
        },
    }
}

Step 6: Configure the Mocker Plugin and Initialize the Bifrost Client

After configuring Bifrost chat interface, configure the Mocker Plugin and initialize the Bifrost Client by mocking rate limiting fallback trigger in the main.go file, as shown below:

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    bifrost "github.com/maximhq/bifrost/core"
    "github.com/maximhq/bifrost/core/schemas"
    mocker "github.com/maximhq/bifrost/plugins/mocker"
)

// --- Pointer helpers ---

func stringPtr(s string) *string { return &s }
func boolPtr(b bool) *bool       { return &b }
func intPtr(i int) *int           { return &i }

// ...

// =====================================================================
// Scenario 1: Mock Error → Fallback Succeeds
// =====================================================================
// Mocker always returns a 429 rate-limit error for OpenAI,
// but AllowFallbacks=true lets Bifrost try Anthropic.

func runScenario1() {
    fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
    fmt.Println("SCENARIO 1: Mock Error → Fallback Succeeds")
    fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
    fmt.Println("  Primary:  OpenAI   (will be mocked with 429 error)")
    fmt.Println("  Fallback: Anthropic (real provider)")
    fmt.Println("  AllowFallbacks: true")
    fmt.Println()

    // Step 2: Configure the Mocker plugin. We will set up a rule that always
    // triggers a 429 rate limit error for OpenAI requests.
    plugin, err := mocker.Init(mocker.MockerConfig{
        Enabled: true,
        Rules: []mocker.MockRule{
            {
                Name:        "openai-rate-limit",
                Enabled:     true,
                Priority:    100,
                Probability: 1.0, // Always trigger
                Conditions: mocker.Conditions{
                    Providers: []string{"openai"},
                },
                Responses: []mocker.Response{
                    {
                        Type:           mocker.ResponseTypeError,
                        AllowFallbacks: boolPtr(true), // ← KEY: allow Bifrost to try fallbacks
                        Error: &mocker.ErrorResponse{
                            Message:    "Rate limit exceeded",
                            Type:       stringPtr("rate_limit"),
                            Code:       stringPtr("429"),
                            StatusCode: intPtr(429),
                        },
                    },
                },
                Latency: &mocker.Latency{
                    Type: mocker.LatencyTypeFixed,
                    Min:  100 * time.Millisecond, // Simulate slight network delay
                },
            },
        },
    })
    if err != nil {
        log.Fatalf("Scenario 1 — plugin creation failed: %v", err)
    }

    // Step 3: Initialize the Bifrost client, attaching our Account definition and the plugin.
    client, initErr := bifrost.Init(context.Background(), schemas.BifrostConfig{
        Account:    &MyAccount{},
        LLMPlugins: []schemas.LLMPlugin{plugin},
        Logger:     bifrost.NewDefaultLogger(schemas.LogLevelInfo),
    })
    if initErr != nil {
        log.Fatalf("Scenario 1 — Bifrost init failed: %v", initErr)
    }
    defer client.Shutdown()

    // Step 4: Execute the ChatCompletionRequest. Bifrost will attempt OpenAI first,
    // encounter the rate limit error from the mocker, and automatically fallback to Anthropic.
    response, bifrostErr := client.ChatCompletionRequest(
        schemas.NewBifrostContext(context.Background(), schemas.NoDeadline),
        buildChatRequest("What is the capital of France? Reply in one sentence."),
    )
    if bifrostErr != nil {
        // Step 5: Handle the final error (if both primary and fallback fail).
        fmt.Printf("  ❌ Request failed: %v\n\n", bifrostErr.Error.Message)
        return
    }

    // Step 6: Process the successful response.
    fmt.Printf("  ✅ Fallback succeeded!\n")
    fmt.Printf("  Provider: %s\n", response.ExtraFields.Provider)
    fmt.Printf("  Response: %s\n\n", *response.Choices[0].Message.Content.ContentStr)
}

// =====================================================================
// Main
// =====================================================================

func main() {
    fmt.Println()
    fmt.Println("╔══════════════════════════════════════════════════╗")
    fmt.Println("║  Bifrost Mocker Plugin — Fallback Demo           ║")
    fmt.Println("╚══════════════════════════════════════════════════╝")
    fmt.Println()

    runScenario1()

    fmt.Println("Done!")
}

Step 7: Run the demo

Once you have configured the Mocker Plugin and initialized the Bifrost Client by mocking rate limiting fallback trigger, run the demo using the command below:

go run .

After running the demo, you should see that a rate limiting error by OpenAI provider triggered an automatic fallback to Anthropic provider as shown below:

Step 8: Mock other fallback triggers

If you want to mock other fallback triggers such as Network connectivity issues, Provider API errors (500, 502, 503, 504), Request timeouts and Authentication failures, clone the demo repo from GitHub using the command below,

git clone https://github.com/TheGreatBonnie/automatic-llm-provider-fallback-demo.git

Then set your LLM provider API keys as environment variables:

export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."

Finally run the demos

go run .

Congratulations! You have successfully implemented automatic LLM provider failover or fall back.

Conclusion

Automatic LLM provider fallback is one of the most effective ways to harden your AI agents against the outages, rate limits, and network issues that are an inevitable part of production.

In this guide, you:

Set up Bifrost as an OpenAI-compatible LLM gateway
Configured multiple AI providers (OpenAI, Anthropic, Gemini)
Implemented a fallback chain so requests automatically move from a failing primary model to backup providers
Tested fallback behavior locally using the Bifrost Mocker plugin without waiting for a real outage

As a next step, explore Bifrost's other reliability features to build an even more resilient AI stack.

Explore Bifrost:

🌐 Website: https://getmax.im/bifrost-home
📦 GitHub: https://git.new/bifrostrepo
📘 Docs (Quickstart): https://getmax.im/bifrostdocs

How To Use Claude Code With Any AI Model Using an LLM Gateway (Bifrost)

Bonnie — Sat, 07 Mar 2026 15:49:40 +0000

Unless you live under a rock, vibe coding has been the talk of the town in software development for a while now since AI coding tools became a thing.

And one of the most popular and capable AI coding tool developers can use today is Claude Code by Anthropic.

Claude Code can read your repository, run commands, modify files, and help implement features directly from the terminal using only Anthropic’s own AI models.

But what if you want to use Claude Code with different LLM providers instead of being tied to a single one?

Maybe you want to:

Switch between Anthropic, OpenAI, or Gemini
Use a cheaper model for simple tasks
Fall back to another provider during outages
Route requests for performance or cost optimization

This is where an LLM gateway becomes incredibly useful.

In this guide, you will learn how to connect Claude Code to any LLM using the Bifrost LLM gateway.

Before we jump in, here is what we will cover:

Why Bifrost LLM gateway?
Setting up and configuring LLM providers with Bifrost LLM gateway
Integrating Claude Code with Bifrost LLM gateway
Running Claude Code with any AI model.
Enabling built-in observability and monitoring
Integrating MCP tools

Let’s dive in.

Why Bifrost LLM gateway?

Bifrost is an open-source LLM gateway built by Maxim AI to route, manage, and optimize requests between your AI application and multiple large language model providers.

The LLM gateway is built using Go (Golang) for performance and below is what makes it stand out:

Blazing fast overhead: At 5,000 requests per second, Bifrost adds less than 15 microseconds of internal overhead per request which is very important at production scale.
Zero-config startup: You can launch Bifrost with a single npx command and configure everything through a web UI.
Built-in fallbacks and load balancing: If a provider fails or rate-limits you, Bifrost automatically routes to a backup. Traffic can be distributed across multiple keys or providers using weighted rules.
Semantic caching: Repeated or similar queries can be served from cache, which helps in cutting costs and reducing latency.
**Observability: **Bifrost offers Prometheus metrics, request tracing, and a built-in web dashboard out of the box.

Bifrost supports 15+ providers including OpenAI, Anthropic, Google Gemini (via Vertex or GenAI), AWS Bedrock, Azure, Mistral, Cohere, Groq, and more.

You can learn more about Bifrost LLM gateway here on there website.

Prerequisites

Before we start, make sure you have the following:

Node.js 18+ (for running Bifrost via npx) or Docker (for containerized deployment)
API keys for the providers you want to use:
- OpenAI: platform.openai.com
- Anthropic: console.anthropic.com
- Google (Gemini): aistudio.google.com or Google Cloud (for Vertex)

Let’s get started!

Setting up and configuring LLM providers with Bifrost

In this section, you will how to set up Bifrost LLM gateway with multiple AI model providers that you can use with Claude Code.

Let’s get started.

Step 1: Install Bifrost using NPX binary

To install Bifrost, first, create your project folder named claude-code-demo and open it using your preferred code editor such as VS Code or Cursor.

Then run the command below with the **-app-dir** flag that determines where Bifrost stores all its data:

npx -y @maximhq/bifrost -app-dir ./my-bifrost-data

Step 2: Create a config.json file

Once you have installed Bifrost in your project, create a config.json file in the ./my-bifrost-data folder. Then add the code below that defines multiple LLM providers and database persistence.

{
  "$schema": "https://www.getbifrost.ai/schema",
  "client": {
    "enable_logging": true,
    "disable_content_logging": false,
    "drop_excess_requests": false,
    "initial_pool_size": 300,
    "allow_direct_keys": false
  },
  "providers": {
    "openai": {
      "keys": [
        {
          "name": "openai-primary",
          "value": "env.OPENAI_API_KEY",
          "models": [],
          "weight": 1.0
        }
      ]
    },
    "anthropic": {
      "keys": [
        {
          "name": "anthropic-primary",
          "value": "env.ANTHROPIC_API_KEY",
          "models": [],
          "weight": 1.0
        }
      ]
    },
    "gemini": {
      "keys": [
        {
          "name": "gemini-primary",
          "value": "env.GEMINI_API_KEY",
          "models": [],
          "weight": 1.0
        }
      ]
    }
  },
  "config_store": {
    "enabled": true,
    "type": "sqlite",
    "config": {
      "path": "./config.db"
    }
  },
  "logs_store": {
    "enabled": true,
    "type": "sqlite",
    "config": {
      "path": "./logs.db"
    }
  }
}

Step 3: Set up your API keys

After creating the config.json file, set your API keys as environment variables so they're never hardcoded using the commands below in the terminal.

export OPENAI_API_KEY="your-openai-api-key"
export ANTHROPIC_API_KEY="your-anthropic-api-key"
export GEMINI_API_KEY="your-gemini-api-key"

Step 4: Start Bifrost Gateway server

Once you have set up your API keys, start the Bifrost LLM gateway server by running the command below again (Make sure to stop the initial running server instance).

npx -y @maximhq/bifrost -app-dir ./my-bifrost-data

Then Bifrost will listen on port 8080, as shown below.

Finally, navigate to the gateway dashboard at http://localhost:8080 as shown below

Integrating Claude Code with Bifrost LLM gateway

In this section, you will learn how to integrate Claude Code with Bifrost LLM gateway in order to use it with any AI model.

Let’s get started.

Step 1: Install Claude Code

To install Claude Code, run the command below in the command line:

npm install -g @anthropic-ai/claude-code

Step 2: Point Claude Code at Bifrost

Once you have installed Claude Code, point it at Bifrost LLM gateway by setting the environment variables below in the terminal where ANTHROPIC_BASE_URL tells Claude Code to send its API requests to Bifrost instead of Anthropic's servers:

export ANTHROPIC_BASE_URL="http://localhost:8080/anthropic"
export ANTHROPIC_API_KEY="dummy-key"

Step 3: Run Claude Code with Any Model

After pointing Claude Code at Bifrost, start and run Claude Code with with any model such OpenAI GPT 5.2-codex model using the command below.

claude --model openai/gpt-5.2-codex

Then you should see Claude Code running, as shown below:

Step 4: Verify the setup

Once Claude Code is running, verify it setup with Bifrost using a simple query such as, “Hello there.” You should see the response in Claude Code, as shown below:

Integrating MCP tools

In this section, you will learn how to integrate MCP tools with Bifrost to allow Claude Code to connect directly and access the tools.

Let’s get started!

Step 1: Connect Bifrost to MCP server

To connect Bifrost to MCP server for let’s say filesystem, update the config.json file with the code below:

{
  "$schema": "https://www.getbifrost.ai/schema",
  "client": {
    "enable_logging": true,
    "disable_content_logging": true,
    "drop_excess_requests": false,
    "initial_pool_size": 300,
    "allow_direct_keys": false
  },

 // ...

  "mcp": {
    "client_configs": [
      {
        "name": "filesystem",
        "connection_type": "stdio",
        "stdio_config": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
        },
        "tools_to_execute": ["*"],
        "tools_to_auto_execute": [
          "read_file",
          "list_directory",
          "create_file",
          "delete_file"
        ]
      }
    ],
    "tool_manager_config": {
      "max_agent_depth": 10,
      "tool_execution_timeout": 300000000000,
      "code_mode_binding_level": "server"
    }
  }
}

Then restart Bifrost server and navigate to the MCP catalog page in the web UI. You should see the filesystem MCP server connected, as shown below:

Step 2: Connect Claude Code to Bifrost MCP

Once you have connected MCP server to Bifrost, add Bifrost as an MCP server to Claude Code using the command below:

claude mcp add --transport http bifrost http://localhost:8080/mcp

Step 3: Execute a coding task

After connecting Claude Code to Bifrost MCP, restart it and execute a simple coding task using the prompt below:

Create a simple calculator program in Python.

It should support:
- addition
- subtraction
- multiplication
- division

The user should input two numbers and an operation, and the program should print the result.

Claude Code should create a python file with the calculator code. Then run the prompt below that analyzes your codebase and creates a Readme file.

Analyze this repository and create a README.md explaining how the project works.

Include the project architecture and instructions for running it locally.

Once Claude Code completes the run, the Readme file should be created, as shown below:

Built-in observability and monitoring

Bifrost provides built-in observability and monitoring by logging all traffic passing through the gateway.

The web interface at http://localhost:8080/logs provides:

Real-time streaming of requests and responses
Token usage tracking per request
Latency measurements
Filtering by provider, model, or conversation content
Full request/response inspection

You can also monitor LLM logs with requests, latency, tokens and cost, a shown below:

Conclusion

In conclusion, Claude Code is already one of the most powerful AI development assistants available today.

By combining it with an LLM gateway like Bifrost unlocks even more flexibility where you can:

Use any AI provider
Dynamically switch models
Integrate MCP tools
Monitor responses, tokens, latency and usage cost

Finally, feel free to explore Bifrost and try it yourself using the links below:

🌐 Website: https://getmax.im/bifrost-home
📦 GitHub: https://git.new/bifrostrepo
📘 Docs (Quickstart): https://getmax.im/bifrostdocs

Building AI Agent With Multiple AI Model Providers Using an LLM Gateway (OpenAI, Anthropic, Gemini & Bifrost)

Bonnie — Tue, 24 Feb 2026 15:11:21 +0000

Imagine building an AI agent that uses only one LLM provider such as OpenAI, Gemini or Anthropic through their specific APIs.

While in production, your AI agent LLM provider hits a rate limit during a traffic spike or has a partial outage or you realize that different tasks in your agent’s workflow are better suited for different AI models entirely.

To avoid such issues, you need to integrate a multi AI model provider system using an LLM gateway.

The LLM gateway handles AI model selection, authentication, failover, load balancing, routing and observability without changing your AI agent code.

In this guide, you will learn how build an AI agent with multi AI model provider consisting of OpenAI, Gemini and Anthropic using Bifrost.

Before we jump in, here is what we will cover:

What is an LLM Gateway (and why Bifrost)?
Setting up Bifrost with multiple AI providers
Building the AI agent
Implementing Load balancing
Implementing Routing Rules

Let’s jump in!

What is an LLM Gateway (and Why Bifrost)?

An LLM gateway is a middleware layer that sits between your AI agent and one or more AI model providers.

Instead of writing code for OpenAI's API format, Anthropic's authentication scheme, and Gemini's endpoint structure, your AI agent simply sends requests to the gateway in a standard format, and the gateway takes care of the rest.

In simple terms, an LLM gateway routes model requests without your agent needing to know how each LLM provider handles requests and responses.

But why will we be using Bifrost in this guide?

Bifrost is an open-source LLM gateway built by Maxim AI to route, manage, and optimize requests between your AI application and multiple large language model providers.

The LLM gateway is built using Go (Golang) for performance and below is what makes it stand out:

Blazing fast overhead: At 5,000 requests per second, Bifrost adds less than 15 microseconds of internal overhead per request which is very important at production scale.
Zero-config startup: You can launch Bifrost with a single npx command and configure everything through a web UI.
Built-in fallbacks and load balancing: If a provider fails or rate-limits you, Bifrost automatically routes to a backup. Traffic can be distributed across multiple keys or providers using weighted rules.
Semantic caching: Repeated or similar queries can be served from cache, which helps in cutting costs and reducing latency.
Observability: Bifrost offers Prometheus metrics, request tracing, and a built-in web dashboard out of the box.

Bifrost supports 15+ providers including OpenAI, Anthropic, Google Gemini (via Vertex or GenAI), AWS Bedrock, Azure, Mistral, Cohere, Groq, and more.

You can learn more about Bifrost LLM gateway here on there website.

Prerequisites

Before we start, make sure you have the following:

Node.js 18+ (for running Bifrost via npx) or Docker (for containerized deployment)
API keys for the providers you want to use:
- OpenAI: platform.openai.com
- Anthropic: console.anthropic.com
- Google (Gemini): aistudio.google.com or Google Cloud (for Vertex)
Python 3.9+ or Node.js for writing the agent code

Setting up Bifrost with Multiple LLM providers

In this section, you will how to set up Bifrost LLM gateway with multiple AI model providers for your AI agent or application.

Let’s get started.

Step 1: Install Bifrost using NPX binary

To install Bifrost, first, create your project folder named multi-provider-agent and open it using your preferred code editor such as VS Code or Cursor.

Then run the command below with the -app-dir flag that determines where Bifrost stores all its data:

npx -y @maximhq/bifrost -app-dir ./my-bifrost-data

Step 2: Create a config.json file

Once you have installed Bifrost in your project, create a config.json file in the ./my-bifrost-data folder. Then add the code below that defines multiple LLM providers and database persistence.

{
  "$schema": "https://www.getbifrost.ai/schema",
  "client": {
    "drop_excess_requests": false
  },
  "providers": {
    "openai": {
      "keys": [
        {
          "name": "openai-primary",
          "value": "env.OPENAI_API_KEY",
          "models": [],
          "weight": 1.0
        }
      ]
    },
    "anthropic": {
      "keys": [
        {
          "name": "anthropic-primary",
          "value": "env.ANTHROPIC_API_KEY",
          "models": [

          ],
          "weight": 1.0
        }
      ]
    },
    "gemini": {
      "keys": [
        {
          "name": "gemini-primary",
          "value": "env.GEMINI_API_KEY",
          "models": [],
          "weight": 1.0
        }
      ]
    }
  },
  "config_store": {
    "enabled": true,
    "type": "sqlite",
    "config": {
      "path": "./config.db"
    }
  }
}

Step 3: Set up your API keys

After creating the config.json file, set your API keys as environment variables so they're never hardcoded using the commands below in the terminal.

export OPENAI_API_KEY="your-openai-api-key"
export ANTHROPIC_API_KEY="your-anthropic-api-key"
export GEMINI_API_KEY="your-gemini-api-key"

Step 4: Start Bifrost Gateway server

Once you have set up your API keys, start the Bifrost LLM gateway server by running the command below again (Make sure to stop the initial running server instance).

npx -y @maximhq/bifrost -app-dir ./my-bifrost-data

Then Bifrost will listen on port 8080, as shown below.

Finally, navigate to the gateway dashboard at http://localhost:8080 as shown below

Step 5: Verify the Setup

After installing and starting Bifrost, you can verify if it's working by running the curl command below in the terminal.

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Then you should get a response from the Bifrost LLM gateway, as shown below.

Building an AI agent with multiple AI models using Bifrost and LangChain (LangGraph)

In this section, you will learn how to build an AI agent with multiple AI models using Bifrost and LangGraph.

You can learn how to set up Bifrost with LangGraph using LangChain SDK here on Bifrost docs.

Let’s get started.

Step 1: Set up a Python virtual environment

To set up a Python virtual environment for your project, run the commands below in the terminal to create and activate a virtual environment.

# Create a virtual environment
python3 -m venv venv

# Activate it
source venv/bin/activate

Step 2: Install LangGraph dependencies

After setting up a Python virtual environment, install LangGraph dependencies in your project by running the command below in the terminal.

pip install langgraph langchain-openai

Step 3: Configure your AI agent

Once you have installed LangGraph dependencies, create an agent.py file in your project folder and add the following code that sets up a Multi-Provider Research Agent with LangGraph.

import os
from typing import TypedDict, Annotated
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
from langchain_core.tools import tool
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
import operator

BIFROST_URL = "http://localhost:8080"

# ─────────────────────────────────────────────
# Model definitions — all pointing at Bifrost
# ─────────────────────────────────────────────

# Deep reasoning: complex planning and analysis
planner_llm = ChatOpenAI(
    model="openrouter/claude-3.7-sonnet",
    base_url=f"{BIFROST_URL}/v1",
    api_key="dummy",
    max_tokens=2048
)

# General purpose: tool use and synthesis
executor_llm = ChatOpenAI(
    model="openai/gpt-4o",
    base_url=f"{BIFROST_URL}/v1",
    api_key="dummy",
    max_tokens=2048
)

# Fast and cheap: lightweight formatting and summaries
summarizer_llm = ChatOpenAI(
    model="gemini/gemini-2.0-flash",
    base_url=f"{BIFROST_URL}/v1",
    api_key="dummy",
    max_tokens=1024
)

# ─────────────────────────────────────────────
# Tools
# ─────────────────────────────────────────────

@tool
def search_web(query: str) -> str:
    """Search the web for information on a given topic."""
    # Replace with a real search implementation (e.g. Tavily, SerpAPI)
    return f"[Search results for '{query}': Sample results would appear here]"

@tool
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression."""
    try:
        result = eval(expression, {"__builtins__": {}})
        return str(result)
    except Exception as e:
        return f"Calculation error: {e}"

tools = [search_web, calculate]
tool_node = ToolNode(tools)
executor_with_tools = executor_llm.bind_tools(tools)

# ─────────────────────────────────────────────
# State
# ─────────────────────────────────────────────

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    research_plan: str
    final_summary: str

# ─────────────────────────────────────────────
# Nodes
# ─────────────────────────────────────────────

def planner_node(state: AgentState) -> dict:
    """
    Uses Claude Opus via Bifrost.
    Analyses the user's request and produces a structured research plan.
    """
    messages = [
        SystemMessage(content="""You are a strategic research planner. 
        Given a user's question, create a clear, step-by-step research plan 
        that identifies: what information is needed, what tools to use, 
        and what the final answer should look like."""),
    ] + state["messages"]

    response = planner_llm.invoke(messages)

    return {
        "messages": [response],
        "research_plan": response.content
    }

def executor_node(state: AgentState) -> dict:
    """
    Uses GPT-4o via Bifrost with tool access.
    Executes the research plan by calling tools and gathering information.
    """
    messages = [
        SystemMessage(content=f"""You are a research executor. 
        Follow this plan carefully and use the available tools to gather 
        the required information:

        {state.get('research_plan', 'Gather information to answer the user question.')}"""),
    ] + state["messages"]

    response = executor_with_tools.invoke(messages)
    return {"messages": [response]}

def summarizer_node(state: AgentState) -> dict:
    """
    Uses Gemini Flash via Bifrost.
    Takes the gathered research and produces a clean, concise final answer.
    """
    # Collect all content from the conversation
    research_content = "\n\n".join([
        msg.content for msg in state["messages"] 
        if hasattr(msg, "content") and msg.content
    ])

    messages = [
        SystemMessage(content="""You are a concise summarizer. 
        Given research findings, produce a clear, well-structured final answer. 
        Be direct and helpful. Remove redundancy."""),
        HumanMessage(content=f"Research gathered:\n\n{research_content}\n\nProvide the final answer.")
    ]

    response = summarizer_llm.invoke(messages)

    return {
        "messages": [response],
        "final_summary": response.content
    }

def should_use_tools(state: AgentState) -> str:
    """Conditional edge: if the executor requested tool calls, run them."""
    last_message = state["messages"][-1]
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "tools"
    return "summarizer"

# ─────────────────────────────────────────────
# Graph assembly
# ─────────────────────────────────────────────

def build_research_agent() -> StateGraph:
    graph = StateGraph(AgentState)

    graph.add_node("planner", planner_node)
    graph.add_node("executor", executor_node)
    graph.add_node("tools", tool_node)
    graph.add_node("summarizer", summarizer_node)

    graph.set_entry_point("planner")
    graph.add_edge("planner", "executor")
    graph.add_conditional_edges(
        "executor",
        should_use_tools,
        {"tools": "tools", "summarizer": "summarizer"}
    )
    graph.add_edge("tools", "executor")   # Loop back after tool use
    graph.add_edge("summarizer", END)

    return graph.compile()

# ─────────────────────────────────────────────
# Run it
# ─────────────────────────────────────────────

if __name__ == "__main__":
    agent = build_research_agent()

    questions = [
        "What are the key differences between transformer and mamba architectures for language models?",
        "If a company grows revenue 23% YoY from $4.2M, what is the new revenue?",
    ]

    for question in questions:
        print(f"\n{'='*60}")
        print(f"Question: {question}")

        result = agent.invoke({
            "messages": [HumanMessage(content=question)],
            "research_plan": "",
            "final_summary": ""
        })

        print(f"\nFinal Answer:\n{result['final_summary']}")

Step 4: Run your agent

After setting up your AI agent, run it by executing the following command in the terminal.

python agent.py

Once the AI agent runs and completes its workflow, you should see the response on the terminal, as shown below.

Implementing Load balancing

In this section, you will learn how to implement load balancing in your AI agent using Bifrost. But before we get started, let’s understand what is load balancing.

What is load balancing in Bifrost?

In Bifrost, Load balancing means distributing AI requests across multiple API keys and AI models instead of sending all traffic to a single key.

Sending all your AI agent traffic to a single API key can lead to the following issues:

You can hit rate limits
Requests can fail when traffic spikes
One key outage breaks everything
Performance becomes unstable

However, if you implement load balancing using Bifrost, your AI agent can:

Share traffic across several keys
Automatically switch if one key fails
Avoid overloading a single provider

Load balancing in Bifrost is implemented using two methods which are weighted load balancing and Model Whitelisting & Filtering.

In weighted load balancing, you assign a weight to each API key where openai-primary handles ~70% of requests and openai-secondary handles ~30%, as shown below.

"providers": {
    "openai": {
      "keys": [
        {
          "name": "openai-primary",
          "value": "env.OPENAI_API_KEY_PRIMARY",
          "models": ["gpt-4o", "gpt-4o-mini",],
          "weight": 0.7
        },
        {
          "name": "openai-secondary",
          "value": "env.OPENAI_API_KEY_SECONDARY",
          "models": [],
          "weight": 0.3
        }
      ]
    }, 
 }

In Model Whitelisting & Filtering, keys can be restricted to specific models for access control and cost management, a shown below. A request for gpt-4o will only be routed to premium-key while a request to gpt-4o-mini will only use standard-key

"providers": {
    "openai": {
      "keys": [
        {
          "name": "premium-key",
          "value": "env.OPENAI_API_KEY_PREMIUM",
          "models": ["gpt-4o", "o1-preview"],
          "weight": 1.0
        },
        {
          "name": "standard-key",
          "value": "env.OPENAI_API_KEY_STANDARD",
          "models": [],
          "weight": 1.0
        }
      ]
    }, 
 }

You can learn more about about load balancing here on Bifrost docs.

Implementing Routing Rules

In this section, you will learn how to implement routing rules in your AI agent. Before we get started, let’s understand what are routing rules in Bifrost.

What are routing rules in Bifrost?

Routing rules in Bifrost are like traffic signs for your AI requests. They tell Bifrost where to send each request based on conditions you define.

Instead of always using the same AI model or provider, routing rules let you say things like, “If the request looks like this, send it to that provider.”

For example:

If a request is for summarization, use a cheaper model
If the user is a premium customer, use a more powerful model
If one provider is too busy, send the request to another provider

Everytime your AI agent sends a request, Bifrost checks these rules. The first rule that matches the request is sent to the chosen provider and model.

If no rule matches the request, Bifrost simply falls back to its default behavior, such as load balancing between providers.

To implement routing rules, define them in the config.json file, as shown below.

"governance": {
    "routing_rules": [
      {
        "id": "rule-uuid-123",
        "name": "Premium Tier Route",
        "description": "Route premium users to fast provider",
        "enabled": true,
        "cel_expression": "headers[\"x-tier\"] == \"premium\"",
        "provider": "openrouter",
        "model": "claude-3.7-sonnet",
        "fallbacks": ["openrouter/gpt-4o", "openrouter/gpt-3.5-turbo"],
        "scope": "global",
        "scope_id": null,
        "priority": 10
      },
      {
        "id": "rule-uuid-456",
        "name": "Budget Overflow Route",
        "description": "Route to cheaper provider when budget is high",
        "enabled": true,
        "cel_expression": "budget_used > 85",
        "provider": "groq",
        "model": "llama-2-70b",
        "fallbacks": [],
        "scope": "team",
        "scope_id": "team-ml-ops",
        "priority": 5
      },
      {
        "id": "team-preference",
        "name": "ML Team Anthropic Route",
        "enabled": true,
        "cel_expression": "team_name == \"ml-research\"",
        "provider": "anthropic",
        "model": "claude-3-opus-20240229",
        "fallbacks": ["bedrock/claude-3-opus"],
        "scope": "team",
        "scope_id": "team-ml-research",
        "priority": 0
      }
    ]
  },

After defining the routing rules, you can pass the routing rules in your AI agent request, as shown below.

# Deep reasoning: complex planning and analysis
planner_llm = ChatOpenAI(
    model="openrouter/claude-3.7-sonnet",
    base_url=f"{BIFROST_URL}/v1",
    api_key="dummy",
    default_headers={
        'x-tier': 'premium',
    },
    max_tokens=2048
)

You can learn more about about routing rules here on Bifrost docs.

Conclusion

In conclusion, building AI agents that rely on a single LLM provider is risky and limits flexibility. By using an LLM gateway like Bifrost, you can create a multi-provider AI agent that is resilient, scalable, and future-proof.

Finally, If you’re building or scaling an AI application and performance is becoming a bottleneck, explore Bifrost and try it yourself:

🌐 Website: https://getmax.im/bifrost-home
📦 GitHub: https://git.new/bifrostrepo
📘 Docs (Quickstart): https://getmax.im/bifrostdocs

How a Go-Based LLM Gateway Achieves Extreme Performance Gains (Bifrost vs LiteLLM)

Bonnie — Wed, 11 Feb 2026 14:29:39 +0000

Unless you live under a rock, AI has been the talk of the town since 2022 when ChatGPT was announced to the world powered by a Large Language Model (LLM).

Since then, the Large Language Models (LLMs) such as OpenAI’s GPT series, Anthropic’s Claude, and Google’s Gemini, have become the back bone of AI-powered applications.

However, as these AI-powered applications scale, they encounter the following issues:

If performance drops or prices rise when using one LLM provider, migrating to another LLM requires changing code frequently.
Using different LLM providers becomes a bottleneck since each LLM provider defines their API requests and responses differently.
Monitoring usage, optimizing cost, and debugging issues across different LLMs becomes a nightmare when everything is scattered across direct LLM provider APIs.

That’s where LLM Gateways comes in.

Understanding what is an LLM gateway?

In simple terms, an LLM gateway can be described as a middle man who routes, manages, optimizes and monitors requests together with responses from your AI-powered app to different LLM providers.

Below is an illustration of an LLM gateway.

In this guide, we will cover how a Go-based LLM gateway named Bifrost achieves extreme performance gains over LiteLLM, a python-based LLM gateway.

Before we get started, here is what we will cover:

Understanding what is an LLM gateway
What is Bifrost and why was it built?
Bifrost vs LiteLLM performance comparison
Advantages of Go-based design architecture over Python-based design architecture.
Bifrost key features that improve performance gains
How to get started with Bifrost

Let’s jump in!

What is Bifrost?

Bifrost is a high-performance LLM gateway designed to route, manage, and optimize requests between your AI application and multiple large language model providers such as OpenAI, Anthropic, Gemini and others.

It acts as a single entry point for all LLM traffic, providing a unified API, built-in observability, and performance optimizations that make it suitable for production AI systems.

You can learn more about Bifrost LLM gateway here on there website.

Why Was Bifrost Built?

As LLM-powered applications moved from experimentation to production, teams began facing several challenges:

**Extreme Latency & Speed: **Existing LLM gateways became performance bottlenecks under high traffic
**Reliability at Scale: **Under heavy load (500+ requests per second), other gateways started failing requests or consuming excessive memory.
Unified Control: Standardizing the fragmented API landscape so developers don't have to rewrite code when switching models.

Instead of being another LLM proxy, Bifrost was built to be the fastest, and most scalable LLM gateway where it is:

Blazing fast: Built in Go, Bifrost introduces <15µs* internal overhead per request at 5000 RPS.
First-class observability: Native Prometheus metrics built-in - no wrappers, no sidecars, just drop it in and scrape.
Flexible transport: Supports HTTP and* gRPC *(planned) *out of the box, so you don’t have to contort your infra to fit the tool. Bifrost bends to *your system, not the other way around.

Feel free to explore Bifrost docs here.

Bifrost vs LiteLLM performance comparison

To compare Bifrost and LiteLLM, some benchmark tests were ran at 500 RPS to compare performance of Bifrost and LiteLLM. Below are the results

Based on the benchmarking data, throughput comparison results between Bifrost and LiteLLM where the number of requests a gateway can successfully process per second (RPS) shows Bifrost performing better than LiteLLM, as shown below.

In Latency Comparison between Bifrost and LiteLLM, Bifrost was ~9.5x faster, with ~54x lower P99 latency, and used 68% less memory than LiteLLM — on t3.medium instance (2 vCPUs) with tier 5 OpenAI Key, as shown below.

When a like-for-like benchmark based on the LiteLLM proxy’s own benchmarking setup was ran with the same load, same mocking behaviour, and same hardware profile to get a clean, apples-to-apples comparison of real-world overheads from the gateway layer itself, Bifrost performed better than LiteLLM, as shown below.

Advantages of Bifrost Go-based design architecture over LiteLLM Python-based design architecture

The performance gap between Bifrost (Go) and LiteLLM (Python) is a good example of why architecture design choice for an LLM gateway is critical for infrastructure tools.

While Python is the undisputed king of AI research and data science, Go (Golang) is widely considered superior for building the infrastructure (gateways, proxies, and cloud-native tools) that serves those models.

Here are the advantages of a Go-based architecture design for an LLM gateway over a Python-based one:

a). Higher Performance and Lower Latency

Go is a compiled language that produces native binaries, while Python is interpreted. This means:

Go executes faster at runtime.
It adds less overhead per request.
It provides more predictable response times under load.

For systems handling thousands of concurrent requests, this leads to lower latency and higher throughput.

b). Efficient Concurrency Model

Go was built with concurrency as a core feature using goroutines and channels. This means:

Goroutines are lightweight and cheap to create.
Go can handle many concurrent requests with minimal memory usage.
Context switching is faster and simpler than Python threads or async tasks.

Python, on the other hand is limited by the Global Interpreter Lock (GIL) and requires complex async frameworks to scale concurrency.

c). Predictable Memory Management

Go’s garbage collector is optimized for low-latency server workloads. This means:

More stable memory usage.
Fewer unpredictable pauses.
Better performance consistency under load.

Python’s memory management can cause higher overhead and less predictable pauses in long-running services.

You can learn more about Bifrost Go-based architecture here on the docs.

Bifrost key features that improve performance gains

Bifrost is designed as a production-grade infrastructure layer rather than just a developer utility. Its core features work in harmony with its Go-based architecture to eliminate the bottlenecks typically found in Python-based proxies like LiteLLM.

Here is a breakdown of how its key features drive significant performance and reliability gains:

a). Adaptive Load Balancing

The Adaptive Load Balancing feature in Bifrost enables the LLM gateway to:

Continuously monitor performance metrics like latency, error rates, and throughput for each provider and API key.
Dynamically adjusts where traffic goes so faster, healthier providers or keys get more requests.
Reduce an endpoint traffic or temporarily removes it when it slows down or starts failing until it recovers.

Bifrost’s adaptive load balancing feature improves performance by reducing slow or failed calls, keeping responses fast, and preventing bottlenecks that hurt overall throughput and reliability.

You can learn more about the Bifrost’s adaptive load balancing feature here on the Bifrost docs.

b). Semantic Caching

The semantic caching feature in Bifrost enables the LLM gateway to:

Not only cache exact matches, but use semantic similarity to detect when requests mean the same thing even if the text is phrased differently.
Return the stored response in milliseconds on a cache hit which is much faster than making a full LLM request.
Reduce repeated external API calls when similar queries occur frequently.

Bifrost’s semantic caching feature improves performance by providing instant responses for many requests and fewer expensive model calls, which cuts both latency and cost.

You can learn more about the Bifrost’s semantic caching feature here on the Bifrost docs.

c). Unified Interfaces

The unified interfaces feature in Bifrost enables the LLM gateway to:

Provide one consistent OpenAI-compatible API no matter which provider (OpenAI, Anthropic, AWS, etc.) is used.
Internally handle provider-specific quirks (input/output formats, errors, rate limits).

Bifrost’s unified interfaces feature improves performance by simplifying your application code and removing overhead by letting requests flow efficiently and reduce expensive error handling or conversions.

You can learn more about the unified interfaces feature here on the Bifrost docs.

d). Built-In Metrics and Observability

The Built-In Metrics and Observability feature enables you to monitor and analyze every AI request and response in real-time where:

Native Prometheus-based metrics is supported without requiring external sidecars or wrappers.
It tracks key performance signals like latency, success rates, cache hit/miss rates, and throughput.
It help teams identify slow paths, provider degradation, and optimization opportunities.

Bifrost’s Built-In Metrics and Observability feature improves performance by helping teams fine-tune configurations and prevent issues before they slow down systems.

You can learn more about the Built-In Metrics and Observability feature feature here on the Bifrost docs.

How to get started with Bifrost LLM gateway

Getting started with Bifrost is designed to be straightforward, especially if you are already using the OpenAI API.

There are two primary ways to integrate it: as a standalone HTTP server (easiest for most) or as a Go package directly in your code.

Let’s get started

Prerequisites

Go 1.23 or higher (not needed if using Docker)
Access to at least one AI model provider (OpenAI, Anthropic, etc.)
API keys for the providers you wish to use

Option A: Using Bifrost as an HTTP Server

This is the most common method. You run Bifrost as a proxy and simply point your application to it.

To use Bifrost as an HTTP server, follow the steps below,

Step 1: Configuration:

Create a file named config.json which tells Bifrost which keys and models to use, as shown below

{
 "openai": {
 "keys": [{
     "value": "env.OPENAI_API_KEY",
     "models": ["gpt-4o-mini"],
     "weight": 1.0
   }]
 }
}

Step 2. Set Environment Variables:

Add your API key to your environment so the config file can read it securely

export OPENAI_API_KEY=your_openai_api_key;

Step 3: Start the Bifrost HTTP Server:

You have two options to run the server, either using Go Binary or a Docker setup if go is not installed.

a. Using Go Binary

To use Go Binary, first, install the transport package:

go install github.com/maximhq/bifrost/transports/bifrost-http@latest

Then run the server (make sure Go is present in the PATH):

bifrost-http -config config.json -port 8080

b. Using Docker

To use Docker, first download the Dockerfile:

curl -L -o Dockerfile https://raw.githubusercontent.com/maximhq/bifrost/main/transports/Dockerfile

Then build the Docker image:

docker build \
--build-arg CONFIG_PATH=./config.json \
--build-arg PORT=8080 \
-t bifrost-transports .

Finally, run the Docker container:

docker run -p 8080:8080 -e OPENAI_API_KEY bifrost-transports

Step 4: Using the API:

Once the server is running, you can send requests to the HTTP endpoints.

curl -X POST http://localhost:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "openai/gpt-4o-mini",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Tell me about Bifrost in Norse mythology."}
  ]
}'

Note: For additional configurations in HTTP server setup, please read this.

Option B: Using Bifrost as a Go Package

If you are building a Go application and want to avoid the network hop of an external proxy, you can embed Bifrost directly.

To use Bifrost as a Go Package, follow the steps below,

Step 1: Go Get Bifrost:

To get Bitfrost, run the following command to install Bifrost as a golang package in your project.

go get github.com/maximhq/bifrost/core@latest

Step 2: Implement Your Account Interface:

To implement your account interface, you first need to create your account which follows Bifrost's account interface.

type BaseAccount struct{}

func (baseAccount *BaseAccount) GetConfiguredProviders() ([]schemas.ModelProvider, error) {
  return []schemas.ModelProvider{schemas.OpenAI}, nil
}

func (baseAccount *BaseAccount) GetKeysForProvider(providerKey schemas.ModelProvider) ([]schemas.Key, error) {
    return []schemas.Key{
      {
        Value:  os.Getenv("OPENAI_API_KEY"),
        Models: []string{"gpt-4o-mini"},
      },
    }, nil
}

func (baseAccount *BaseAccount) GetConfigForProvider(providerKey schemas.ModelProvider) (*schemas.ProviderConfig, error) {
    return &schemas.ProviderConfig{
                NetworkConfig:            schemas.DefaultNetworkConfig,
                ConcurrencyAndBufferSize: schemas.DefaultConcurrencyAndBufferSize,
    }, nil
}

Bifrost uses these methods to get all the keys and configurations it needs to call the providers. You can check Additional Configurations for further customisations.

Step 3: Initialize Bifrost:

To initialize Bifrost, set up the Bifrost instance by providing your account implementation.

account := BaseAccount{}

client, err := bifrost.Init(schemas.BifrostConfig{
  Account: &account,
})

Step 4: Use Bifrost:

Make your First LLM Call!

bifrostResult, bifrostErr := client.ChatCompletionRequest(
     context.Background(),
     &schemas.BifrostRequest{
         Provider: schemas.OpenAI,
         Model: "gpt-4o-mini", // make sure you have configured gpt-4o-mini in your account interface
         Input: schemas.RequestInput{
         ChatCompletionInput: bifrost.Ptr([]schemas.Message{{
                 Role:    schemas.RoleUser,
                 Content: schemas.MessageContent{
                     ContentStr: bifrost.Ptr("What is a LLM gateway?"),
             },
             }}),
          },
       },
  )

  // you can add model parameters by passing them in Params: &schemas.ModelParameters{...yourParams} in ChatCompletionRequest.

For more settings and configurations, check out the Documentation.

Bonus: You can use Maxim’s pre-made plugin from [github.com/maximhq/bifrost/plugins](https://github.com/maximhq/bifrost/tree/main/plugins) to add observability to Bifrost in just a single line by installing the package using the command below,

go get github.com/maximhq/bifrost/plugins/maxim

Then add observability as shown below.

maximPlugin, err := maxim.NewMaximLoggerPlugin(os.Getenv("MAXIM_API_KEY"), os.Getenv("MAXIM_LOG_REPO_ID"))

client, err := bifrost.Init(schemas.BifrostConfig{
  Account: &account,
  Plugins: []schemas.Plugin{maximPlugin},
})

Remember to get your Maxim API Key and Log Repo ID from here.

Conclusion

In conclusion, scaling your AI-powered app from a proof-of-concept to a production-grade AI application can be a headache if you don’t use a fast and scalable LLM gateway*.*

While Python-based proxies like LiteLLM are excellent for early development, they eventually become the bottleneck in high-throughput environments.
Bifrost eliminates this hurdle by moving the gateway logic to a high-performance Go-based architecture.

By choosing Bifrost, you gain:

Infrastructure Efficiency that handle 10x more traffic with 68% less memory compared to LiteLLM gateway
Zero-Latency Overhead with internal processing in microseconds ($<15\mu s$), not milliseconds.
**Production Stability with **100% success rates even under heavy concurrency.

Finally, If you’re building or scaling an AI application and performance is becoming a bottleneck, explore Bifrost and try it yourself:

🌐 Website: https://getmax.im/bifrost-home
📦 GitHub: https://git.new/bifrostrepo
📘 Docs (Quickstart): https://getmax.im/bifrostdocs
📊 Benchmark vs LiteLLM: https://www.getmaxim.ai/blog/bifrost-a-drop-in-llm-proxy-40x-faster-than-litellm/

Test it in your own workload and see how a performance-first LLM gateway can change your system’s behavior at scale.

Converting Figma Design To Next.js Code In Minutes

Bonnie — Tue, 02 Dec 2025 15:24:03 +0000

In this guide, you will learn how to convert Figma designs into production-ready Next.js code code in minutes using Kombai, a specialized frontend AI agent that's about to become your new best friend.

Before we jump in, here is what we will cover:

Understanding what Kombai AI agent is
Configuring your Tech stack
Generating and reviewing a code plan
Generating, running and previewing code
Analyzing output results

Here is a preview of the final results.

Understanding what is Kombai AI Agent

Kombai is a highly specialized AI agent built for frontend developme*nt,* designed to automate the conversion of Figma designs into clean, production-ready code.

It is a domain-specific agent, meaning its AI models are fine-tuned for the nuances of UI (User Interface) creation, making it more effective at this task than general-purpose coding assistants.

Here is a breakdown of Kombai key capabilities:

Multi-input support: Works with Figma designs, text instructions, images, or existing code
Tech stack aware: Supports 30+ frontend libraries including React, Next.js, Material UI, Tailwind, and more
Smart planning: Generates editable development plans before complex tasks using plan mode.
Codebase integration: Scans and reuses existing components and theme variables in your codebase.
Auto-fixing: Automatically fixes TypeScript and linting errors after generating code from Figma designs or images.
Sandbox preview: Run and test generated code in a local environment
Three modes: Plan Mode for code plan generation, Code Mode for code generation, and Ask Mode for codebase understanding.
Preview browser: Kombai browser lets you preview your app’s local deployment in the browser with built-in listeners so you can iterate fast by sending elements and errors back to Kombai as context.

You can learn more about Kombai AI agent here on Kombai docs.

Prerequisites

To fully understand this tutorial, you need to have a basic understanding of Next.js

A Kombai AI account (they have a free tier).
A Figma account with a design file you want to convert.
Visual Studio Code (or a supported IDE like Cursor).
The Kombai AI VS Code extension.
A new or existing Next.js project.

Step 1: Setting Up Your Project and the Kombai Agent

In this section, you will learn how to set up your Next.js project and Kombai AI agent in your IDE (VS Code, Cursor, WindSurf, etc).

Let’s get started.

First, open your Next.js project in your IDE or set up one using the command below.

npx create-next-app@15.5.6 kombai-nextjs-app --yes

Then Install the Kombai AI extension from the marketplace, as shown below.

Once the Kombai extension is installed, click Sign In button in Kombai. Then you will be redirected to the Kombai website to Sign up or log in to your Kombai account.

After signing in, you will be redirected back to the IDE.

Step 2: Scan and Configure your tech stack

Once you have set up your project and the Kombai extension in your IDE, configure your tech stack.

The Kombai agent offers a wide range of tech stacks which lets you generate code that aligns with your workspace’s requirements.

In this case, our Tech stack will be Next.js, and TypeScript. To configure your tech stack, follow the steps as shown below and then save the configuration.

Step 3: Define Code Generation Rules

After scanning and configuring your tech stack, set persistent instructions for Kombai using rules and Agents.md files. The rules provide project level instructions to Kombai in order to enforce specific coding standards, architectural patterns, and output formats

To set the rules or instructions, create a AGENTS.md file in your project and add the project rules or instructions.

You can generate the project instructions by first taking screen shots of your Figma design, as shown below.

Then navigate to Google Gemini, add the screenshot to the chat and generate the instructions using the prompt below.

Give me a prompt for generating a Next.js + TypeScript + Tailwind css web app 
from the provided Figma designs. Describe structure of each page section in 
detail

Once the instructions have been generated, add them to your AGENTS.md file, as shown below.

After that, Kombai automatically picks up the **AGENTS.md** file stored, as shown below.

Step 4: Connect Figma and add your Figma design to Kombai

Once you have defined code generation rules, connect your Figma account with Kombai in order to access your Figma design and generate code based on them, as shown below.

Once you have connected your Figma account, copy your Figma design link, and add it to Kombai, as shown below.

Step 5: Generate, and review code plan

After connecting your Figma account and adding your Figma designs to Kombai, use Kombai plan mode to generate a detailed code plan for the given input before starting the code generation, as shown below.

You can learn more about Kombai plan mode here on Kombai docs.

Step 6: Generate, Run and Fix Code Errors

Once the coding plan is approved or updated, Kombai will generate the code based on the plan, and auto-fix any TS or linting errors found in the generated code, as shown below.

After that, Kombai will run the development server and you can fix any build errors, as shown below.

Step 7: Preview your App using Kombai Browser

After generating code and fixing errors, run the code in Kombai Browser to preview the generated code.

If you find any visual mismatches in the preview, you can tag DOM elements and suggest Kombai to make the necessary changes. Kombai will regenerate the code accordingly, as shown below.

Step 8: Analyzing Kombai Figma Design to Next.js Code Output Results

Once you have run and previewed your app, analyze the generated code and the UI to make sure it is close to what you wanted.

From the output results, Kombai gives you clean, semantic JSX that a human would write since the agent understands layout and structure, not just layers.

Kombai gets you 80-90% of the way where it builds the perfect UI scaffolding, which is the most laborious part. You, the developer, are still needed for the last 10-20% and that's the fun part.

Also, as you can see from the preview results below, Kombai was able to generate frontend UI that is pixel perfect with the Figma design. The code only requires minimal tweaks to match the desired UI design.

What Differentiates Kombai from other Figma Design to Code tools

After using general coding agents, MCPs and Kombai to convert Figma designs into Next.js Code, Kombai significantly outperforms these other AI tools in building UX & UI from Figma, images, or text based prompts as shown below in benchmarks for real-world frontend tasks.

Here are the key reasons for its high-quality output:

"Human-Like" UX Interpretation:
- Unlike older tools that required strict layer naming or auto-layout in Figma, Kombai uses deep learning models to understand the design visually, similar to how an experienced human developer would.
- It intelligently infers structure, component boundaries, spacing, and layout hierarchies even from messy or non-ideal design files.
Workflow Integration and Safety:
- Kombai integrates directly into developer IDEs (like VS Code).
- Planning: For complex tasks, it generates an editable development plan (often in Markdown) before writing code.
- Sandbox Preview: It can spin up a local development server to preview the generated UI in isolation to validate the output before it touches your main codebase.
- Error Correction: It automatically attempts to fix linting and TypeScript errors, and you can feed runtime errors back to the agent for correction.
Codebase Awareness:
- It can analyze your existing repository to detect your current tech stack, styling frameworks, and component libraries. This allows it to generate code that is consistent and integrates seamlessly into your project's architecture.

In essence, Kombai acts as a highly specialized AI partner for frontend teams, taking on the task of building the user interface shell so human developers can focus on complex application logic and unique user experiences.

Conclusion

In conclusion, Kombai AI agent changes the developer's role where it eliminates the most time-consuming, least creative part of frontend development.

Note that this isn't about replacing developers but upgrading their frontend developement workflow.

You are no longer a translator for a designer but a reviewer and integrator of high-quality code, which allows you to move 10x faster and focus on what actually matters: your app's logic, state, and data flow.

Stop hand-coding your UI boilerplate. Grab a free Kombai account, install the VS Code extension, and try converting one of your own Figma frames.

You won't just be surprised by how much time you get back, you will change how you approach frontend development.

Converting Figma Design To React + Material UI Code In Minutes

Bonnie — Wed, 19 Nov 2025 16:17:06 +0000

TL;DR

Imagine if you could convert your Figma designs into production-ready React + Material UI code faster than you can grab a coffee.

In this guide, you will learn how to convert Figma designs into production-ready React code in minutes using Kombai, a specialized frontend AI agent that's about to become your new best friend.

Before we jump in, here is what we will cover:

What is Kombai?
Setting up the Kombai AI Agent in your IDE (VS Code, Cursor, etc.)
Connecting Figma with Kombai
Adding Figma design to Kombai
Configuring your tech stack
Reviewing code generation plan
Running & previewing your app using Kombai browser

Here is a preview of the final results.

What is Kombai?

Kombai is an AI agent purpose-built for frontend development. It generates beautiful, functional frontends from Figma, text, images, or code, understanding your codebase and best practices of 30+ frontend libraries.

Key features:

Multi-input support: Works with Figma designs, text instructions, images, or existing code
Tech stack aware: Supports 30+ frontend libraries including React, Next.js, Material UI, Tailwind, and more
Smart planning: Generates editable development plans before complex tasks
Codebase integration: Scans and reuses existing components and theme variables
Auto-fixing: Automatically fixes TypeScript and linting errors
Sandbox preview: Run and test generated code in a local environment
Three modes: Plan Mode for code plan generation, Code Mode for code generation, and Ask Mode for codebase understanding.
Preview browser: Kombai browser lets you preview your app’s local deployment in the browser with built-in listeners so you can iterate fast by sending elements and errors back to Kombai as context.

You can learn more about Kombai AI agent here on Kombai docs.

Prerequisites

To fully understand this tutorial, you need to have a basic understanding of React

A Kombai AI account (they have a free tier).
A Figma account with a design file you want to convert.
Visual Studio Code (or a supported IDE like Cursor).
The Kombai AI VS Code extension.
A new or existing React project (e.g., created with create-react-app or Vite).

Step 1: Set Up Your Project and the Kombai Agent

In this section, you will learn how to set up your React project and Kombai AI agent in your IDE (VS Code, Cursor, WindSurf, etc).

Let’s get started.

First, open your React project in your IDE or set up one using the command below.

npx create-react-app figma-kombai-demo

Then Install the Kombai AI extension from the marketplace, as shown below.

Once the Kombai extension is installed, click Sign In button in Kombai. Then you will be redirected to the Kombai website to Sign up or log in to your Kombai account.

After signing in, you will be redirected back to the IDE.

Step 2: Connecting Figma and adding your Figma design to Kombai

In this section, you will learn how to connect your Figma account to Kombai and add your Figma design to convert it into React code.

Let’s get started.

First, connect your Figma account with Kombai in order to access your Figma design and generate code based on them, as shown below.

Once you have connected your Figma account, copy your Figma design link, and add it to Kombai, as shown below.

Step 3: Define Code Generation Rules

After adding your Figma design URL, set persistent instructions for Kombai using rules and Agents.md files. The rules provide project level instructions to Kombai in order to enforce specific coding standards, architectural patterns, and output formats

To set the rules or instructions, create a AGENTS.md file in your project and add the project rules or instructions.

You can generate the project instructions by first taking screen shots of your Figma design, as shown below.

Then navigate to Google Gemini, add the screenshot to the chat and generate the instructions using the prompt below.

Give me a prompt for generating a React + Material UI web app 
from the provided Figma designs. Describe structure of each page section in 
detail

Once the instructions have been generated, add them to your AGENTS.md file, as shown below.

After that, Kombai automatically picks up the AGENTS.md file stored, as shown below.

Step 4: Scan and Configure your tech stack

Once you have managed project rules, configure your tech stack. Kombai offers a wide range of tech stack. This lets you generate code that aligns with your workspace’s requirements.

In this case, our Tech stack will be React, TypeScript and Material UI. To configure your tech stack, follow the steps as shown below and then save the configuration.

Step 5: Generate, and Review Code Plan

After configuring your tech stack, use Kombai plan mode to generate a detailed code plan for the given input before starting the code generation, as shown below.

You can learn more about Kombai plan mode here on Kombai docs.

Step 6: Generating code

Once the plan is approved or updated, Kombai starts the code generation process in the workset. Working set refers to the set of files generated by Kombai during the code generation process, as shown below.

Step 7: Running & previewing your app using Kombai browser

After generating the code, Kombai will run the development server and fix any errors.

Also, Kombai browser lets you preview your app’s local deployment in the browser, with built-in listeners so you can iterate fast by sending elements and errors back to Kombai as context.

To open the preview, click the Start Preview button below the Kombai input box. Kombai will start the dev server.

Once the server is runnning, click the Kombai Browser button to open the browser preview, as shown below.

Step 8: Analyzing Kombai output results

Once you have run and previewed your app, analyze the generated code and the UI to make sure it is close to what you wanted.

With other tools, you'll see an endless nesting of divs, often with no semantic meaning, because the tool is just tracing layer groups.

However, with Kombai, you'll get clean, semantic JSX that a human would write. Kombai understands layout and structure, not just layers, as shown below in the App.tsx file.

import { useState } from 'react';
import type { FC } from 'react';
import { Box, Toolbar, Typography } from '@mui/material';
import Sidebar from './components/Sidebar';
import TopBar from './components/TopBar';
import StatCard from './components/StatCard';
import RevenueChart from './components/RevenueChart';
import YearlyBackupChart from './components/YearlyBackupChart';
import FinancialSummaryChart from './components/FinancialSummaryChart';
import ProjectsOverviewCard from './components/ProjectsOverviewCard';
import WeeklyEarningChart from './components/WeeklyEarningChart';
import EmployeeTaskTable from './components/EmployeeTaskTable';
import BestSellingProducts from './components/BestSellingProducts';
import { mockQuery } from './data/dashboardMockData';

const App: FC = () => {
  const [mobileOpen, setMobileOpen] = useState(false);

  const handleDrawerToggle = () => {
    setMobileOpen(!mobileOpen);
  };

  return (
    <Box sx={{ display: 'flex', minHeight: '100vh' }}>
      <Sidebar mobileOpen={mobileOpen} onDrawerToggle={handleDrawerToggle} />

      <Box sx={{ flexGrow: 1, display: 'flex', flexDirection: 'column' }}>
        <TopBar onMenuClick={handleDrawerToggle} />

        <Box
          component="main"
          sx={{
            flexGrow: 1,
            p: { xs: 2, sm: 3 },
            bgcolor: 'background.default',
            overflowY: 'auto'
          }}
        >
          <Toolbar />

          {/* Statistics Cards */}
          <Box
            sx={{
              display: 'grid',
              gridTemplateColumns: {
                xs: '1fr',
                sm: 'repeat(2, 1fr)',
                md: 'repeat(3, 1fr)',
                lg: 'repeat(6, 1fr)'
              },
              gap: 3,
              mb: 3
            }}
          >
            {mockQuery.statistics.map((stat) => (
              <StatCard key={stat.id} {...stat} />
            ))}
          </Box>

          {/* Charts Row 1 */}
          <Box
            sx={{
              display: 'grid',
              gridTemplateColumns: { xs: '1fr', lg: '2fr 1fr' },
              gap: 3,
              mb: 3
            }}
          >
            <RevenueChart
              data={mockQuery.revenueData}
              stats={mockQuery.revenueStats}
            />
            <YearlyBackupChart {...mockQuery.yearlyBackup} />
          </Box>

          {/* Charts Row 2 */}
          <Box
            sx={{
              display: 'grid',
              gridTemplateColumns: { xs: '1fr', md: 'repeat(3, 1fr)' },
              gap: 3,
              mb: 3
            }}
          >
            <FinancialSummaryChart {...mockQuery.financialSummary} />
            <ProjectsOverviewCard {...mockQuery.projectsOverview} />
            <WeeklyEarningChart {...mockQuery.weeklyEarning} />
          </Box>

          {/* Tables Row */}
          <Box
            sx={{
              display: 'grid',
              gridTemplateColumns: { xs: '1fr', lg: '2fr 1fr' },
              gap: 3,
              mb: 3
            }}
          >
            <EmployeeTaskTable tasks={mockQuery.employeeTasks} />
            <BestSellingProducts products={mockQuery.bestSellingProducts} />
          </Box>

          {/* Footer */}
          <Box sx={{ textAlign: 'center', py: 2 }}>
            <Typography variant="body1" sx={{ color: 'text.secondary' }}>
              Design and Developed by{' '}
              <Typography
                component="a"
                href="https://getnextjs.com"
                target="_blank"
                rel="noopener noreferrer"
                sx={{ color: 'secondary.main', textDecoration: 'underline' }}
              >
                GetNextJs Templates
              </Typography>
            </Typography>
          </Box>
        </Box>
      </Box>
    </Box>
  );
};

export default App;

From the output results, Kombai gets you 80-90% of the way where it builds the perfect UI scaffolding, which is the most laborious part. You, the developer, are still needed for the last 10-20% and that's the fun part.

So, is Kombai the Best Choice for converting Figma Design to React code in minutes?

After using general coding agents, MCPs and Kombai to convert Figma designs into React Code, Kombai significantly outperforms these other AI tools in building UX & UI from Figma, images, or text based prompts as shown below in benchmarks for real-world frontend tasks.

Here are the key reasons for its high-quality output:

Understands Design Intent: Unlike other AI tools that require perfect Figma designs (like strict auto-layouts and layer naming), Kombai's AI agent is trained to interpret the visual design. It understands logical groupings, spacing, and layout intentions, even from "messy" Figma files.
Codebase & Tech Stack Aware: You can configure Kombai for your specific tech stack. It can scan your existing codebase to reuse your own components and styles and even integrate with popular libraries like Tailwind CSS, MUI, **and **Shadcn UI.
**Generates Readable & Maintainable Code: **Kombai analyzes the entire design, identifies repeating UI elements, and automatically generates them as reusable React components. This promotes a modular, DRY (Don't Repeat Yourself) codebase from the start.
Agentic & Iterative Workflow: Kombai is built for frontend teams and the "Plan, Code, Preview" loop is a game-changer. You review a plan, preview the component in a sandbox, and ask for changes before any code is written to your files. This gives you full control and trust in the process.
Focuses on the 80%: Kombai intelligently handles the 80% of UI work that is tedious (layout, styling, component boilerplate) so you can focus on the 20% that matters (logic, data fetching, and state management).

If your goal is to ship React UIs that look exactly like the Figma file, respect your repo conventions, and compile error-free on the first try, Kombai is currently the only AI agent purposely built to do exactly that—nothing more, nothing less.

Conclusion

In conclusion, Kombai AI agent changes the developer's role where it eliminates the most time-consuming, least creative part of frontend development.

Note that this isn't about replacing developers but upgrading their frontend developement workflow.

Stop hand-coding your UI boilerplate. Grab a free Kombai account, install the VS Code extension, and try converting one of your own Figma frames.

You won't just be surprised by how much time you get back, you will change how you approach frontend development.

Comparison of the Best Figma To Code AI Tools

Bonnie — Tue, 04 Nov 2025 15:12:27 +0000

TL;DR

For many professional frontend teams, Figma files are the primary source of design instructions.

Developers currently use image exports or Figma MCPs with existing agents, which often struggle with complex, real-world designs. These MCPs can also be context-inefficient, leading to model hallucinations.

In this guide, we will compare the best two AI tools for converting Figma design to code in minutes. These two AI tools are:

Kombai: a specialized AI agent which is purpose-built to "think" like a frontend developer, and convert Figma designs into high-quality UI code across a configurable, robust tech stack.
Framelink MCP: a protocol-based server that acts as a "universal translator," and gives design context from Figma directly into your general-purpose AI coding assistant (e.g., Cursor, Claude, or VS Code).

Before we get started, here is what we will cover:

What is Kombai?
What is Framelink MCP?
Head-to-Head comparison of Kombai vs Framelink MCP
Testing workflows and code outputs of Kombai vs Framelink MCP
The final verdict on which tool is right for you

Here is a preview of the final results between Kombai and Framelink MCP.

What is Kombai?

Key features:

Multi-input support: Works with Figma designs, text instructions, images, or existing code
Tech stack aware: Supports 30+ frontend libraries including React, Next.js, Material UI, Tailwind, and more
Smart planning: Generates editable development plans before complex tasks
Codebase integration: Scans and reuses existing components and theme variables
Auto-fixing: Automatically fixes TypeScript and linting errors
Sandbox preview: Run and test generated code in a local environment
Two modes: Code mode for generation, Ask mode for codebase understanding

You can learn more about Kombai AI agent here on Kombai docs.

What is Framelink MCP?

Framelink MCP (Model Context Protocol) is a server that bridges Figma design files with AI-powered coding tools, such as Claude Code, Cursor or GitHub Copilot on VS Code.

Key Features:

Context-Rich Generation: Moves beyond "screenshot-to-code" guesswork.
IDE Integration: Designed to live inside your AI-powered editor (Cursor, VS Code, Windsurf, etc.).
Developer-in-Control: The developer still drives the process via prompts, using the MCP as their "Figma expert."

You can learn more about Framelink MCP here.

Now that you have learned what Kombai agent and Framelink MCP are, let us see how they compare in a head-to-head comparison.

Head-to-Head comparison of Kombai vs Framelink MCP

The difference between Kombai and Framelink MCP boils down to specialization versus flexibility and workflow integration.

Kombai significantly outperforms generic coding agents + Frontier models + MCPs in building UX from Figma, image, or text based prompts as shown below in benchmarks for real-world frontend tasks.

Here is the head-to-head comparison of the Kombai agent and the Framelink MCP.

Feature	Kombai Agent	Framelink MCP
Functionality	Generates code directly.	Provides context to another AI tool (which then generates code).
Code Output	Highly Configurable (React, Next.js, support for multiple UI libraries (MUI, Shadcn, etc.), and advanced styling options).	Depends entirely on your AI assistant (React, Vue, Svelte, Angular, etc.)—if the LLM knows it, the MCP can enable it.
Figma Reliance	Highly flexible; performs well with "messy" designs.	Benefits greatly from well-structured files (Dev Mode, variables, components).
Workflow	Generate in a sandbox, then copy/paste into the project.	Prompt in editor, AI writes code directly into the file.
Code Quality	Production-ready code with high compilation success but may need tweaks.	Depends on the quality of the connected LLM in your IDE and prompt quality.
Context Awareness	Can scan the local codebase to adhere to local styling conventions and theme files.	Can be instructed via prompt to use existing components and architecture.
Flexibility	Limited to Kombai's comprehensive but defined supported tech stack.	Can be used for virtually any framework or language the connected LLM supports.

Testing workflows and code outputs of Kombai vs Framelink MCP

In this section, we will convert a Figma design into frontend code in two scenarios. In the first scenario, we will use Kombai extension on a code editor of your choice to convert a Figma design into frontend code.

Then in scenario two, we will use Framelink MCP on a code editor of your choice to provide a Figma design as context to an AI coding tool to generate frontend code using a stack of your choice.

After that, we will compare the results from both scenarios and determine which tool is better at converting Figma designs into pixel perfect frontend UI.

Here is the Figma design we will be using in both scenarios. You can get it here on the Figma community.

Let us get started.

Scenario 1: The Kombai Figma Design-to-Code Workflow

To get started with Kombai agent, follow the set up guide in the Kombai docs, as shown below.

Once you have set up Kombai, follow the steps below to convert a Figma design into frontend code.

Let us jump in.

Step 1: Connect Figma

To add a Figma design as context, you need to connect your Figma account with Kombai. This lets Kombai access your Figma design and generate code based on them.

Here is how to connect your Figma account to Kombai:

Step 2: Add Figma design URL

Once you have connected your Figma account, copy the Figma design link, as shown below.

Then in the Enter the link to your Figma frame modal, add the Figma URL and click Confirm, as shown below.

Step 3: Configure your tech stack

After adding your Figma design URL, configure your tech stack. Kombai offers a wide range of tech stack. This lets you generate code that aligns with your workspace’s requirements.

To configure your tech stack, follow the steps as shown below and then save the configuration.

Step 4: Plan for complex tasks

After configuring your tech stack, you can plan for complex tasks. Kombai always generates an editable plan for you to approve or update. This ensures that the task and generated code is always in your control.

Complexity of a task is determined by the number of sections, images, icons, global store entities, queries, etc. required in the code.

You can plan for complex tasks, as shown below.

Once the plan is generated, click the Approve Plan & Start Coding button to accept the plan and start the code generation process, as shown below.

Step 5: Generate Code

Step 6: Run and fix code errors

After generating the code, Kombai will run the development server and fix any errors, as shown below.

Once the development server is running, navigate to the localhost URL in the terminal to preview the frontend code UI in the browser, as shown below.

As you can see from the preview results, Kombai was able to generate frontend code that is pixel perfect with the Figma design. The code only requires minimal tweaks to match the desired UI design.

Scenario 2: The Framelink MCP Figma Design-to-Code Workflow

To get started with Framelink MCP, follow the set up guide in the Framelink docs, as shown below.

Once you have set up Framelink MCP, follow the steps below to convert a Figma design into frontend code.

Let us jump in.

Step 1: Copy a link to a Figma frame

The MCP server compresses the data it receives from the Figma API by almost 90%. Even still, complex designs can overwhelm AI agents with too much information.

To do that, right click on the frame or group you'd like to implement, then select Copy/Paste as and choose Copy link to selection, as shown below.

Step 2: Paste the link into your editor

Once you have a link to the Figma frame or group, you can make a request to your editor's AI agent.

A request as simple as "Implement this Figma frame" along with the link should be enough to get the agent to call the MCP's get_figma_data function, but more context is often helpful in getting the best results, as shown below.

Step 3: Generate Code

After submitting your request, your coding agent will get to work. It should call the MCP's get_figma_data function with the link you provided and start the code generation process, as shown below.

Step 4: Run and fix code errors

After generating the code, your coding agent will run the development server and fix any errors, as shown below.

Once the development server is running, navigate to the localhost URL in the terminal to preview the frontend code UI in the browser, as shown below.

As you can see from the preview results, the coding agent was not able to generate frontend code that is pixel perfect with the Figma design. The code requires a lot of tweaks to match the desired UI design.

Conclusion: Which Tool is Right for You?

In conclusion, both Kombai and Framelink MCP offer powerful solutions for converting Figma designs into code, but they cater to different needs and workflows.

Kombai is a specialized AI agent that excels at generating high-quality, production-ready UI code directly from Figma designs.

Its strengths lie in its configurable tech stack, its ability to handle complex and even "messy" designs, and its feature of generating an editable development plan before starting complex tasks.

The Kombai agent is the ideal choice for developers and teams who prioritize a streamlined workflow, desire highly configurable code output, and want a tool that can intelligently interpret and convert intricate designs with minimal manual intervention.

Framelink MCP, on the other hand, acts as a "universal translator" that provides rich design context from Figma directly into your existing AI-powered coding assistant, such as those in Cursor, Claude, or VS Code.

Its primary advantage is its flexibility; it can be used with virtually any framework or language that your connected LLM supports.

The Framelink MCP is best suited for developers who prefer to remain in their familiar coding environment, want to maintain a high degree of control over the code generation process through prompting, and require the adaptability to work with a wide variety of technologies.

Ultimately, the decision between Kombai and Framelink MCP comes down to a choice between a specialized, end-to-end solution and a flexible, integrated tool.

If your priority is to get high-quality, production-ready code with a specialized tool, Kombai is the better option. If you value flexibility and want to enhance your existing AI-powered workflow with rich design context, Framelink MCP is the more suitable choice.

Easily Perform AI-powered Code Reviews In Minutes (CodeRabbit + GitHub)

Bonnie — Thu, 03 Apr 2025 16:31:53 +0000

TL;DR

In this article, you will learn how to perform AI-powered code reviews using CodeRabbit and GitHub to catch bugs and potential issues in your code.

Before we jump in, here is what we will cover:

What are code reviews?
What is CodeRabbit?
Performing code reviews using CodeRabbit

What are Code Reviews?

Imagine you’ve just written some code for a project—like a feature for a website or an app.

You’re proud of it, but before it gets added to the main project (often called "merging" into the "main branch"), someone else on your team takes a look at it.

That’s a code review!

It’s like having a friend proofread your homework before you turn it in. The goal is to make sure your code works well, is easy to understand, and doesn’t accidentally break anything.

You can learn more about code reviews here on GitLab

What is CodeRabbit?

Now, let’s talk about CodeRabbit.

Imagine instead of waiting for a busy teammate to review your code, you had a super-smart robot helper who could do it instantly.

That’s what CodeRabbit is—an AI-powered tool that reviews your code for you!

You can learn more about CodeRabbit here on CodeRabbit docs

Prerequisites

To fully understand this tutorial, you need to have a basic understanding of React or Next.js.

Let's jump in.

Getting Started with CodeRabbit

In this section, we will create a Blog app and add it to a repository. Then, we will integrate the repository with CodeRabbit, an AI-powered code review tool, to get a review for each commit in a pull request.

Let's get started.

Step 1: Create a Next.js application by running the code snippet below in your terminal.

npx create-next-app@latest blogapp

Step 2: Select your preferred configuration settings. For this tutorial, we'll be using TypeScript and Next.js App Router.

Step 3: Create a blogapp repository and push the Blog app code into the repository, as shown below.

Step 4: To integrate CodeRabbit into your workflow, visit coderabbit.ai and click the Get a free trial button.

Step 5: Next, sign up with your Git provider. In this case, I will use GitHub as my Git provider.

Step 6: Authorize coderabbitai to access your account and click the Add Repositories button at the top right corner to connect your repository to CodeRabbit.

Step 7: Select the repository you want to add to CodeRabbit, as shown below. Then click the Install & Authorize button.

Once the installation is done, you should see that your repository was added to the Repositories section.

Now, CodeRabbit is fully integrated into our repositories and ready to review code changes. It is as simple as that.

Creating sample pull requests

In this section, we will create a new branch in the blogapp repository and switch to the branch. Then we will update the codebase with the Blog app functionality that contains potential issues such as,

Code Quality Issues
Logical & Functional Errors
Security vulnerabilities
Performance Bottlenecks
Best Practices & Code Standards
Documentation & Readability Issues
Dependency & Compatibility Issues

After that, we will create a pull request and review it using CodeRabbit.

Let’s get started.

Step 1: Create a new branch named todoapp using the command below in the command line.

git checkout -b blogapp-functionality

Step 2: Create a src/components/Header.tsx file and paste the following code into the file.

import Link from "next/link";

export const Header = () => {
  return (
    <header className="bg-white shadow-md">
      <nav className="container mx-auto px-4 py-4">
        <ul className="flex space-x-4">
          <li>
            <Link href="/" className="text-primary hover:text-primary-dark">
              Home
            </Link>
          </li>
          <li>
            <Link
              href="/login"
              className="text-primary hover:text-primary-dark">
              Login
            </Link>
          </li>
          <li>
            <Link
              href="/createPost"
              className="text-primary hover:text-primary-dark">
              Create Post
            </Link>
          </li>
        </ul>
      </nav>
    </header>
  );
};

export default Header

Step 3: Create a src/app/api/login/route.ts file and paste the following code into the file.

import { NextResponse } from "next/server";
import jwt from "jsonwebtoken";

const SECRET_KEY = "my-secret-key";

export async function POST(request: Request) {
  const { username, password } = await request.json();

  if (username === "admin" && password === "password") {
    const token = jwt.sign({ username }, SECRET_KEY, { expiresIn: "1h" });
    return NextResponse.json({ success: true, token });
  } else {
    return NextResponse.json(
      { success: false, message: "Invalid credentials" },
      { status: 401 }
    );
  }
}

Step 4: Create a src/app/api/posts/route.ts file and paste the following code into the file.

import { NextResponse } from "next/server";
import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

export async function GET() {
  try {
    const posts = await prisma.post.findMany();
    return NextResponse.json(posts);
  } catch (error) {
    return NextResponse.json(
      { error: "Error fetching posts" },
      { status: 500 }
    );
  }
}

export async function POST(request: Request) {
  const { title, content } = await request.json();

  const result = await prisma.$queryRaw`
    INSERT INTO Post (title, content) VALUES (${title}, ${content})
  `;

  return NextResponse.json(result, { status: 201 });
}

Step 5: Create a src/app/createPost/page.tsx file and paste the following code into the file.

"use client";

import type React from "react";
import { useState } from "react";
import axios from "axios";

const CreatePost = () => {
  const [title, setTitle] = useState("");
  const [content, setContent] = useState("");

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    try {
      await axios.post("/api/posts", { title, content });
    } catch (error) {
      console.error("Error creating post:", error);
    }
  };

  return (
    <form onSubmit={handleSubmit} className="max-w-md mx-auto space-y-4">
      <h1 className="text-3xl font-bold text-center mb-6">Create Post</h1>
      <input
        type="text"
        value={title}
        onChange={(e) => setTitle(e.target.value)}
        placeholder="Title"
        className="w-full p-2 border rounded"
      />
      <textarea
        value={content}
        onChange={(e) => setContent(e.target.value)}
        placeholder="Content"
        className="w-full p-2 border rounded h-32"
      />
      <button
        type="submit"
        className="w-full bg-primary text-white p-2 rounded">
        Create Post
      </button>
    </form>
  );
};

export default CreatePost;

Step 6: Create a src/app/login/page.tsx file and paste the following code into the file.

"use client";

import type React from "react";
import { useState } from "react";
import { useRouter } from "next/navigation";
import axios from "axios";

const Login = () => {
  const [username, setUsername] = useState("");
  const [password, setPassword] = useState("");
  const router = useRouter();

  const handleLogin = async (e: React.FormEvent) => {
    e.preventDefault();
    try {
      const response = await axios.post("/api/login", { username, password });
      if (response.data.success) {
        localStorage.setItem("token", response.data.token);
        router.push("/");
      }
    } catch (error) {
      alert("Login failed");
    }
  };

  return (
    <form onSubmit={handleLogin} className="max-w-md mx-auto space-y-4">
      <h1 className="text-3xl font-bold text-center mb-6">Login</h1>
      <input
        type="text"
        value={username}
        onChange={(e) => setUsername(e.target.value)}
        placeholder="Username"
        className="w-full p-2 border rounded"
      />
      <input
        type="password"
        value={password}
        onChange={(e) => setPassword(e.target.value)}
        placeholder="Password"
        className="w-full p-2 border rounded"
      />
      <button
        type="submit"
        className="w-full bg-primary text-white p-2 rounded">
        Login
      </button>
    </form>
  );
};

export default Login;

Step 7: Go to the src/app/page.tsx file and paste the following code into the file.


import { useState, useEffect } from "react";
import axios from "axios";

const Home = () => {
  const [posts, setPosts] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    const fetchPosts = async () => {
      try {
        const response = await axios.get("/api/posts");
        setPosts(response.data);
      } catch (error) {
        console.log("Error fetching posts:", error);
      } finally {
        setLoading(false);
      }
    };
    fetchPosts();
  });

  const handleRefresh = () => {
    setLoading(true);

    axios
      .get("/api/posts")
      .then((response) => {
        setPosts(response.data);
        setLoading(false);
      })
      .catch((error) => {
        console.log("Error refreshing posts:", error);
        setLoading(false);
      });
  };

  if (loading) return <div className="text-center text-2xl">Loading...</div>;

  return (
    <div className="space-y-6">
      <h1 className="text-4xl font-bold text-center mb-8">Blog Posts</h1>
      <button onClick={handleRefresh} className="w-full mb-4">
        Refresh
      </button>
      {posts.map((post: any) => (
        <div key={post.id} className="bg-white shadow-md rounded-lg p-6">
          <h2 className="text-2xl font-semibold mb-2">{post.title}</h2>
          <p className="text-gray-600">{post.content}</p>
        </div>
      ))}
    </div>
  );
};

export default Home;

Step 8: Go to src/app/layout.tsx file and paste the following code into the file.

import type React from "react";
import { Header } from "@/components/Header";
import "./globals.css";

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang="en">
      <body className="min-h-screen bg-gray-100">
        <Header />
        <main className="container mx-auto mt-8 px-4">{children}</main>
      </body>
    </html>
  );
}

Step 9: Push the changes into the blogapp repository. Then click the Compare & Pull Request button if you are using GitHub as your Git provider.

Step 10: Then, create the pull request by clicking the Create Pull Request Button.

After that, CodeRabbit will start processing the new changes in the pull request and provide a review.

Analyzing CodeRabbit's Feedback

After the Coderabbit bot processes new code changes, CodeRabbit automatically generates a comprehensive pull request summary, as shown below.

Next, CodeRabbit provides a detailed walkthrough that breaks down the code changes introduced as shown below.

After that, CodeRabbit provides a table listing all changes in each file and a change summary.

Next, CodeRabbit provides a sequence diagram for code changes, giving reviewers a clear visualization of the control flow.

After that, Coderabbit identifies potential issues in each file as described below.

a). Issues in the src/components/Header.tsx file

First, CodeRabbit identifies an issue in which the Header component has both named and default exports, which is unnecessary and could lead to confusion. CodeRabbit then recommends choosing one export pattern.

Next, CodeRabbit identifies an issue with undefined Tailwind custom color classes and suggests updating the Tailwind config file to define the classes.

Lastly, CodeRabbit suggests enhancing header navigation accessibility and responsiveness

b). Issues in the src/app/api/login/route.ts file

First, CodeRabbit identifies authentication security issues and suggests several security improvements that are needed.

Next, CodeRabbit identifies an issue where sensitive values are hardcoded and suggests using environment variables instead.

c). Issues in the src/app/api/posts/route.ts file

CodeRabbit identifies a SQL Injection vulnerability issue. Then it suggests using Prisma's built-in methods instead of using template literals with $queryRaw which is unsafe.

After that, CodeRabbit suggests adding authentication middleware and improving error handling.

d). Issues in the src/app/createPost/page.tsx file

CodeRabbit identifies an issue with form validation. Then it suggests adding form submission validation and better error handling.

Then CodeRabbit suggests adding a loading state to the submit button to prevent double submissions.

e). Issues in the src/app/login/page.tsx file

CodeRabbit identifies a potential issue. Then it suggests enhancing security and error handling in login flow.

Next, CodeRabbit suggests improving form accessibility by adding labels and ARIA attributes.

f). Issues in the src/app/page.tsx file

CodeRabbit identifies infinite re-renders, error handling with console.log, and error state management issues.

Then CodeRabbit identifies an issue where the handleRefresh function duplicates the posts fetching logic with inconsistent error handling.

Advanced CodeRabbit Features

In this section, we will explore CodeRabbit features such as Committable Suggestions, Chat functionality, Custom review instructions, and Integration with existing CI/CD pipelines.

Committable Suggestions

CodeRabbit provides actionable suggestions, including a Committable Suggestion feature that allows you to apply suggested changes directly by clicking the Commit Suggestion button.

For example, CodeRabbit provides a code snippet that you can add to your code to fix the issue of hardcoded sensitive values.

### Chat Functionality

CodeRabbit provides chat functionality where there are three ways to chat with the CodeRabbit bot, as shown below.

For example, let’s ask CodeRabbit to give a detailed explanation of an identified issue.

Custom review instructions

CodeRabbit provides an option for adding custom review instructions to your project. The custom review instructions should be based on the patterns in your codebase to help maintain consistency across the project.

To add custom instructions in the Blog app codebase, create a .github/coderabbit.yaml file in the blog app repository. Then copy and paste the YAML content below into the file.

review:
  path_instructions:
    - path: "src/app/api/**/*.ts"
      instructions: |
        - Ensure all API routes have proper error handling with appropriate status codes
        - Validate request bodies using TypeScript types
        - Use NextResponse for consistent response formatting
        - Implement authentication checks where required
        - Use try-catch blocks for database operations
        - Avoid raw SQL queries, prefer Prisma's query builder

    - path: "src/app/**/*.tsx"
      instructions: |
        - Components should be functional components using TypeScript
        - Use appropriate hooks for state management
        - Implement proper loading states for async operations
        - Follow the container/presentation pattern where applicable
        - Use Tailwind CSS classes consistently
        - Handle client-side errors gracefully with user feedback

    - path: "src/components/**/*.tsx"
      instructions: |
        - Keep components focused and reusable
        - Implement proper TypeScript props interface
        - Use semantic HTML elements
        - Ensure consistent styling with Tailwind CSS
        - Add JSDoc comments for component documentation

    - path: "src/lib/**/*.ts"
      instructions: |
        - Maintain pure utility functions
        - Add comprehensive TypeScript types
        - Include proper error handling
        - Add unit tests for utilities
        - Document complex logic with comments

  general_guidelines: |
    - Follow TypeScript best practices and maintain type safety
    - Use consistent error handling patterns
    - Implement proper authentication checks
    - Follow Next.js 13+ app router conventions
    - Keep components and functions small and focused
    - Use meaningful variable and function names
    - Add comments for complex business logic
    - Ensure proper error messages for user feedback
    - Follow REST API best practices
    - Use environment variables for sensitive data

After that, Commit and push the changes into the blogapp repository.

Integration with CI/CD pipelines

CodeRabbit can be integrated with CI/CD pipelines to perform static analysis, configuration checks automatically, and even suggest code fixes as part of your build and deployment process.

For example, to integrate CodeRabbit to GitHub actions CI/CD pipeline, create a .github/workflows/coderabbit.yml file and paste the following code into the file.

name: 'CodeRabbit PR Review'
on: [pull_request]
permissions:
  contents: read
  pull-requests: write
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: coderabbitai/ai-pr-reviewer@latest
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}  # Required for advanced features

After that, Commit and push the changes into the blogapp repository.

Conclusion

We covered a lot in this tutorial. I hope you learned what code reviews and CodeRabbit are, how to get started with CodeRabbit, and how to use it to perform AI-powered code reviews.

Feel free to leave your feedback in the comments.

AI-Powered Frontend UI Components Generator (Next.js, GPT4, Langchain, & CopilotKit)

Bonnie — Mon, 06 May 2024 18:27:32 +0000

TL;DR

In this article, you will learn how to build an AI-powered frontend UI components generator that enables you to generate Next.js Tailwind CSS UI components with an implementation tutorial.

We'll cover how to:

Build the UI components generator web app using Next.js, TypeScript, and Tailwind CSS.
Use CopilotKit to integrate AI functionalities into the UI components generator.
Integrate an embedded code editor to make changes to the generated code.

Prerequisites

To fully understand this tutorial, you need to have a basic understanding of React or Next.js.

Here are the tools required to build the AI-powered UI components generator:

Ace Code Editor - an embeddable code editor written in JavaScript that matches the features and performance of native editors.
Langchain - provides a framework that enables AI agents to search the web and research any topic.
OpenAI API - provides an API key that enables you to carry out various tasks using ChatGPT models.
Tavily AI - a search engine that enables AI agents to conduct research and access real-time knowledge within the application.
CopilotKit - an open-source copilot framework for building custom AI chatbots, in-app AI agents, and text areas.

Project Set up and Package Installation

First, create a Next.js application by running the code snippet below in your terminal:

npx create-next-app@latest aiuigenerator

Select your preferred configuration settings. For this tutorial, we'll be using TypeScript and Next.js App Router.

Next, install Ace code editor, and Langchain packages and their dependencies.

npm install react-ace @langchain/langgraph

Finally, install the CopilotKit packages. These packages enable us to retrieve data from the React state and add AI copilot to the application.

npm install @copilotkit/react-ui @copilotkit/react-textarea @copilotkit/react-core @copilotkit/backend

Congratulations! You're now ready to build an AI-powered blog.

Building The UI Components Generator Frontend

In this section, I will walk you through the process of creating the UI components generator frontend with static content to define the generator’s user interface.

To get started, go to /[root]/src/app in your code editor and create a folder called components. Inside the components folder, create two files named Header.tsx, and CodeTutorial.tsx .

In the Header.tsx file, add the following code that defines a functional component named Header that will render the generator’s navbar.

"use client";

import Link from "next/link";

export default function Header() {
  return (
    <>
      <header className="flex flex-wrap sm:justify-start sm:flex-nowrap z-50 w-full bg-gray-800 border-b border-gray-200 text-sm py-3 sm:py-0 ">
        <nav
          className="relative max-w-7xl w-full mx-auto px-4 sm:flex sm:items-center sm:justify-between sm:px-6 lg:px-8"
          aria-label="Global">
          <div className="flex items-center justify-between">
            <Link
              className="w-full flex-none text-xl text-white font-semibold p-6"
              href="/"
              aria-label="Brand">
              AI-UI-Components-Generator
            </Link>
          </div>
        </nav>
      </header>
    </>
  );
}

In the CodeTutorial.tsx file, add the following code that defines a functional component named CodeTutorial that renders the UI components generator homepage that will display the generated UI components, embedded code editor and generated implementation tutorial.

"use client";

import Markdown from "react-markdown";
import { useState } from "react";
import AceEditor from "react-ace";
import React from "react";

export default function CodeTutorial() {
  const [code, setCode] = useState<string[]>([
    `<h1 class="text-red-500">Hello World</h1>`,
  ]);
  const [codeToDisplay, setCodeToDisplay] = useState<string>(code[0] || "");
  const [codeTutorial, setCodeTutorial] = useState(``);

  function onChange(newCode: any) {
    setCodeToDisplay(newCode);
  }

  return (
    <>
      <main className=" min-h-screen px-4">
        <div className="w-full h-full min-h-[70vh] flex justify-between gap-x-1 ">
          <div className="w-2/3 min-h-[60vh] rounded-lg bg-white shadow-lg p-2 border mt-8 overflow-auto">
            <div
              className="w-full min-h-[60vh] rounded-lg"
              dangerouslySetInnerHTML={{ __html: codeToDisplay }}
            />
          </div>
          <AceEditor
            placeholder="Placeholder Text"
            mode="html"
            theme="monokai"
            name="blah2"
            className="w-[50%] min-h-[60vh] p-2 mt-8 rounded-lg"
            onChange={onChange}
            fontSize={14}
            lineHeight={19}
            showPrintMargin={true}
            showGutter={true}
            highlightActiveLine={true}
            value={codeToDisplay}
            setOptions={{
              enableBasicAutocompletion: true,
              enableLiveAutocompletion: true,
              enableSnippets: false,
              showLineNumbers: true,
              tabSize: 2,
            }}
          />
        </div>
        <div className="w-10/12 mx-auto">
          <div className="mt-8">
            <h1 className="text-white text-center text-xl font-semibold p-6">
              Code Tutorial
            </h1>
            {codeTutorial ? (
              <Markdown className="text-white">{codeTutorial}</Markdown>
            ) : (
              <div className="text-white">
                The Code Tutorial Will Appear Here
              </div>
            )}
          </div>
        </div>
      </main>
    </>
  );
}

Next, go to /[root]/src/page.tsx file, and add the following code that imports CodeTutorial and Header components and defines a functional component named Home.

import React from "react";
import Header from "./components/Header";
import CodeTutorial from "./components/CodeTutorial";

export default function Home() {
  return (
    <>
      <Header />
      <CodeTutorial />
    </>
  );
}

Next, remove the CSS code in the globals.css file and add the following CSS code.

@tailwind base;
@tailwind components;
@tailwind utilities;

@tailwind base;
@tailwind components;
@tailwind utilities;

body {
  height: 100vh;
  background-color: rgb(16, 23, 42);
}

pre {
  margin: 1rem;
  padding: 1rem;
  border-radius: 10px;
  background-color: black;
  overflow: auto;
}

h2,
p {
  padding-bottom: 1rem;
  padding-top: 1rem;
}

code {
  margin-bottom: 2rem;
}

Finally, run the command npm run dev on the command line and then navigate to http://localhost:3000/.

Now you should view the UI Components generator frontend on your browser, as shown below.

Integrating AI Functionalities To The Components Generator Using CopilotKit

In this section, you will learn how to add an AI copilot to the UI components generator to generate UI components code and implementation tutorial using CopilotKit.

CopilotKit offers both frontend and backend packages. They enable you to plug into the React states and process application data on the backend using AI agents.

First, let's add the CopilotKit React components to the blog frontend.

Adding CopilotKit to the UI Component Generator Frontend

Here, I will walk you through the process of integrating the UI components generator with the CopilotKit frontend to facilitate UI components code and implementation tutorial generation.

To get started, use the code snippet below to import useMakeCopilotReadable, and useCopilotAction, custom hooks at the top of the /[root]/src/app/components/CodeTutorial.tsx file.

import {
  useCopilotAction,
  useMakeCopilotReadable,
} from "@copilotkit/react-core";

Inside the CodeTutorial function, below the state variables, add the following code that uses the useMakeCopilotReadable hook to add the code that will be generated as context for the in-app chatbot. The hook makes the code readable to the copilot.

useMakeCopilotReadable(codeToDisplay);

Below the code above, add the following code that uses the useCopilotAction hook to set up an action called generateCodeAndImplementationTutorial which will enable generation of UI components code and implementation tutorial.

The action takes in two parameters called code and tutorial which enables generation of a UI component code and implementation tutorial.

The action contains a handler function that generates a UI component code and implementation tutorial based on a given prompt.

Inside the handler function, codeToDisplay state is updated with the newly generated code while codeTutorial state is updated with the newly generated tutorial, as shown below.

useCopilotAction(
    {
      name: "generateCodeAndImplementationTutorial",
      description:
        "Create Code Snippet with React.js(Next.js), tailwindcss and an implementation tutorial of the code generated.",
      parameters: [
        {
          name: "code",
          type: "string",
          description: "Code to be generated",
          required: true,
        },
        {
          name: "tutorial",
          type: "string",
          description:
            "Markdown of step by step guide tutorial on how to use the generated code accompanied with the code. Include introduction, prerequisites and what happens at every step accompanied with code generated earlier. Don't forget to add how to render the code on browser.",
          required: true,
        },
      ],
      handler: async ({ code, tutorial }) => {
        setCode((prev) => [...prev, code]);
        setCodeToDisplay(code);
        setCodeTutorial(tutorial);
      },
    },
    [codeToDisplay, codeTutorial]
  );

After that, go to /[root]/src/app/page.tsx file and import CopilotKit frontend packages and styles at the top using the code below.

import { CopilotKit } from "@copilotkit/react-core";
import { CopilotSidebar } from "@copilotkit/react-ui";
import "@copilotkit/react-ui/styles.css";

Then use CopilotKit to wrap the CopilotSidebar and CodeTutorial components, as shown below. The CopilotKit component specifies the URL for CopilotKit's backend endpoint (/api/copilotkit/) while the CopilotSidebar renders the in-app chatbot that you can give prompts to generate UI components code and implementation tutorial.

export default function Home() {
  return (
    <>
      <Header />
      <CopilotKit url="/api/copilotkit">
        <CopilotSidebar
          instructions="Help the user generate code. Ask the user if to generate its tutorial."
          defaultOpen={true}
          labels={{
            title: "Code & Tutorial Generator",
            initial: "Hi! 👋 I can help you generate code and its tutorial.",
          }}>
          <CodeTutorial />
        </CopilotSidebar>
      </CopilotKit>
    </>
  );
}

After that, run the development server and navigate to http://localhost:3000. You should see that the in-app chatbot was integrated into the UI components generator.

Adding CopilotKit Backend to the UI Components Generator

Here, I will walk you through the process of integrating the UI components generator with the CopilotKit backend that handles requests from frontend, and provides function calling and various LLM backends such as GPT.

Also, we will integrate an AI agent named Tavily that can research any topic on the web.

To get started, create a file called .env.local in the root directory. Then add the environment variables below in the file that hold your ChatGPT and Tavily Search API keys.

OPENAI_API_KEY="Your ChatGPT API key"
TAVILY_API_KEY="Your Tavily Search API key"

To get the ChatGPT API key, navigate to https://platform.openai.com/api-keys.

To get the Tavily Search API key, navigate to https://app.tavily.com/home

After that, go to /[root]/src/app and create a folder called api. In the api folder, create a folder called copilotkit.

In the copilotkit folder, create a file called research.ts. Then Navigate to this research.ts gist file, copy the code, and add it to the research.ts file

Next, create a file called route.ts in the /[root]/src/app/api/copilotkit folder. The file will contain code that sets up a backend functionality to process POST requests. It conditionally includes a "research" action that performs research on a given topic.

Now import the following modules at the top of the file.

import { CopilotBackend, OpenAIAdapter } from "@copilotkit/backend"; // For backend functionality with CopilotKit.
import { researchWithLangGraph } from "./research"; // Import a custom function for conducting research.
import { AnnotatedFunction } from "@copilotkit/shared"; // For annotating functions with metadata.

Below the code above, define a runtime environment variable and a function named researchAction that researches a certain topic using the code below.

// Define a runtime environment variable, indicating the environment where the code is expected to run.
export const runtime = "edge";

// Define an annotated function for research. This object includes metadata and an implementation for the function.
const researchAction: AnnotatedFunction<any> = {
  name: "research", // Function name.
  description: "Call this function to conduct research on a certain topic. Respect other notes about when to call this function", // Function description.
  argumentAnnotations: [ // Annotations for arguments that the function accepts.
    {
      name: "topic", // Argument name.
      type: "string", // Argument type.
      description: "The topic to research. 5 characters or longer.", // Argument description.
      required: true, // Indicates that the argument is required.
    },
  ],
  implementation: async (topic) => { // The actual function implementation.
    console.log("Researching topic: ", topic); // Log the research topic.
    return await researchWithLangGraph(topic); // Call the research function and return its result.
  },
};

Then add the code below under the code above to define an asynchronous function that handles POST requests.

// Define an asynchronous function that handles POST requests.
export async function POST(req: Request): Promise<Response> {
  const actions: AnnotatedFunction<any>[] = []; // Initialize an array to hold actions.

  // Check if a specific environment variable is set, indicating access to certain functionality.
  if (process.env.TAVILY_API_KEY) {
    actions.push(researchAction); // Add the research action to the actions array if the condition is true.
  }

  // Instantiate CopilotBackend with the actions defined above.
  const copilotKit = new CopilotBackend({
    actions: actions,
  });

  // Use the CopilotBackend instance to generate a response for the incoming request using an OpenAIAdapter.
  return copilotKit.response(req, new OpenAIAdapter());
}

How To Generate UI Components

Now go to the in-app chatbot you integrated earlier and give it a prompt like, “generate a contact form.”

Once it is done generating, you should see the contact form component generated together with its implementation tutorial, as shown below. You can also modify the generated code using the embedded code editor.

Congratulations! You’ve completed the project for this tutorial.

Conclusion

CopilotKit is an incredible tool that allows you to add AI Copilots to your products within minutes. Whether you're interested in AI chatbots and assistants or automating complex tasks, CopilotKit makes it easy.

If you need to build an AI product or integrate an AI tool into your software applications, you should consider CopilotKit.

You can find the source code for this tutorial on GitHub: https://github.com/TheGreatBonnie/AIPoweredUIComponentsGenerator