Breadboard

A library for prototyping generative AI applications.

This library was inspired by the hardware maker community and their boundless creativity. They make amazing things with off-the-shelf parts and a breadboard, just wiring things together and trying this and that until it works.

Breadboard is an attempt to bring the same spirit of creativity and simplicity to making generative AI applications.

This library's design emphasizes two key properties:

1️⃣ Ease and flexibility of wiring. Make wiring prototypes easy and fun.

2️⃣ Modularity and composability. Easily share, remix, reuse, and compose prototypes.

Requirements

Breadboard requires Node version >=v19.0.0.

Installing the library

To install breadboard, run:

npm install @google-labs/breadboard

You will also need the LLM Starter Kit:

npm install @google-labs/llm-starter

The LLM Starter Kit comes with Breadboard nodes helpful for building LLM-based applications including the promptTemplate node, append node, generateText node, and more.

Using breadboard

Just like for hardware makers, the wiring of a prototype begins with the Board.

import { Board } from "@google-labs/breadboard";

const board = new Board();

Breadboards are all nodes and wires. Nodes do useful things, and wires flow control and data between them.

Placing things on the board is simple. This example places an input and an output node on the board:

const input = board.input();
const output = board.output();

Wiring things is also simple:

input.wire("say->hear", output);

The statement above wires the say property of the input node to the hear property of the output node.

The wire method is chainable, so you can wire multiple wires at once. Wiring can also happen in both directions, allowing for more expressivity and flexibility.

Here's an example: a board that uses PaLM API to generate text:

const output = board.output();
board
  .input()
  .wire("say->", output)
  .wire(
    "say->text",
    kit
      .generateText()
      .wire("completion->hear", output)
      .wire("<-PALM_KEY", kit.secrets(["PALM_KEY"]))
  );

You can run boards using runOnce and run methods. The runOnce is the simplest; it takes inputs and produces a set of outputs:

const result = await board.runOnce({
  say: "Hi, how are you?",
});
console.log("result", result);

When run, the output of the sample board above will look something like this:

result { say: 'Hi, how are you?', hear: 'Doing alright.' }

The run method provides a lot more flexibility on how the board run happens, and is described in more detail Chapter 8: Continuous runs of Breadboard tutorial.

Breadboard is designed for modularity. You can easily save boards: they nicely serialize as JSON:

const json = JSON.stringify(board, null, 2);
await writeFile("./docs/tutorial/news-summarizer.json", json);

You can load this JSON from URLs:

const NEWS_BOARD_URL =
  "https://gist.githubusercontent.com/dglazkov/55db9bb36acd5ba5cfbd82d2901e7ced/raw/google-news-headlines.json";
const board = Board.load(NEWS_BOARD_URL);

You can include them into your own boards, similar to JS modules, and then treat them as nodes in your graph:

board
  .input()
  .wire(
    "say->text",
    board.invoke(NEWS_BOARD_URL).wire("text->hear", board.output())
  );

You can even create board templates by leaving "slots" in your board for others to fill in:

const input = board.input();
input.wire(
  "topic->",
  board.slot("news").wire(
    "headlines->",
    template.wire("topic<-", input).wire(
      "prompt->text",
      kit
        .generateText()
        .wire("<-PALM_KEY.", kit.secrets(["PALM_KEY"]))
        .wire("completion->summary", board.output())
    )
  )
);

For more information

To learn more about Breadboard, here are a couple of resources:

• Breadboard Tutorial -- learn how to use breadboard step-by-step, from easy to more complex.
• Node Types Reference - learn about the nodes that come built-in with Breadboard.
• Wiring spec -- all the different ways to wire nodes.
• Sample boards, helpfully visualized with Mermaid (click on the the link next to "Original:" heading to see the board code):
  • Simple text completion
  • Google Search summary
  • Google News summary
  • Math problem solver
  • Endless debate between Albert and Friedrich
  • ReAct
  • ReAct with slot
  • Example of calling "ReAct with slot"
  • Semantic retrieval

Packages

Package Name	NPM	Description
Core
@google-labs/breadboard		The core breadboard library
Kits
@google-labs/core-kit		Library for foundational board operations like append and import
@google-labs/json-kit		Library for working with JSON in boards
@google-labs/llm-starter		Library for working with LLMs (Large Language Models) in boards
@google-labs/palm-kit		Library for working with the PaLM API in boards
Tools & Support Libraries
@google-labs/breadboard-server		Library for running boards as Google Cloud Functions
@google-labs/breadboard-ui		Web Components for building applications with Breadboard
@google-labs/create-breadboard-kit		NPM init/create script for creating a kit
@google-labs/create-breadboard		NPM init/create script for creating a board
Examples
@google-labs/cloud-function	Unpublished	Example of using Cloud Functions with Breadboard
@google-labs/coffee-bot-board	Unpublished	Example board that can order coffee
@google-labs/graph-playground	Unpublished	Examples project that runs some sample boards
@google-labs/hello-world	Unpublished	Example board based on the Breadboard tutorial
Internal/Experiments
@google-labs/breadboard-cli	Unpublished	Command-line tool for generating, running, and debugging boards
@google-labs/breadboard-web	Unpublished	Library for running boards in a web browser
@google-labs/breadboard-website	Unpublished	The documentation website for Breadboard
@google-labs/breadbuddy	Unpublished	Library for generating web applications from boards
@google-labs/discovery-types	Unpublished	Library which generates TypeScript declarations from the PaLM API Discovery Document
@google-labs/graph-integrity	Unpublished	Library that validates boards
@google-labs/node-nursery-web	Unpublished	A place for experimenting with board nodes that aren't yet ready for their own package (web specific)
@google-labs/node-nursery	Unpublished	A place for experimenting with board nodes that aren't yet ready for their own package (general)
@google-labs/node-proxy-server	Unpublished	Library that allows running nodes remotely
@google-labs/pinecone-kit	Unpublished	Library for working with the Pinecone vector database in boards
Deprecated
@google-labs/graph-runner		Legacy library for executing boards