golc

README

🦜️🔗 GoLC

🚀 Building Go applications with LLMs through composability

GoLC is an innovative project heavily inspired by the LangChain project, aimed at building applications with Large Language Models (LLMs) by leveraging the concept of composability. It provides a framework that enables developers to create and integrate LLM-based applications seamlessly. Through the principles of composability, GoLC allows for the modular construction of LLM-based components, offering flexibility and extensibility to develop powerful language processing applications. By leveraging the capabilities of LLMs and embracing composability, GoLC brings new opportunities to the Golang ecosystem for the development of natural language processing applications.

Installation

Use Go modules to include golc in your project:

go get github.com/hupe1980/golc

Usage

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/hupe1980/golc"
	"github.com/hupe1980/golc/chain"
	"github.com/hupe1980/golc/model/llm"
)

func main() {
	openai, err := llm.NewOpenAI(os.Getenv("OPENAI_API_KEY"))
	if err != nil {
		log.Fatal(err)
	}

	conversationChain, err := chain.NewConversation(openai)
	if err != nil {
		log.Fatal(err)
	}

	ctx := context.Background()

	result1, err := golc.SimpleCall(ctx, conversationChain, "What year was Einstein born?")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(result1)

	result2, err := golc.SimpleCall(ctx, conversationChain, "Multiply the year by 3.")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(result2)
}

Output:

Einstein was born in 1879.
1879 multiplied by 3 equals 5637.

For more example usage, see _examples.

Contributing

Contributions are welcome! Feel free to open an issue or submit a pull request for any improvements or new features you would like to see.

References

• https://github.com/hwchase17/langchain/tree/master
• https://www.promptingguide.ai/

License

This project is licensed under the MIT License. See the LICENSE file for details.

Documentation

Overview

Package golc provides functions for executing chains.

Index

• Variables
• func BatchCall(ctx context.Context, chain schema.Chain, inputs []schema.ChainValues, ...) ([]schema.ChainValues, error)
• func Call(ctx context.Context, chain schema.Chain, inputs schema.ChainValues, ...) (schema.ChainValues, error)
• func SimpleCall(ctx context.Context, chain schema.Chain, input any, ...) (string, error)
• type BatchCallOptions
• type CallOptions
• type SimpleCallOptions

Variables

var (
	// Verbose controls the verbosity of the chain execution.
	Verbose = false

	// ErrMultipleInputs is returned when calling a chain with more than one expected input is not supported.
	ErrMultipleInputs = errors.New("chain with more than one expected input")
	// ErrMultipleOutputs is returned when calling a chain with more than one expected output is not supported.
	ErrMultipleOutputs = errors.New("chain with more than one expected output")
	// ErrMultipleOutputs is returned when calling a chain with more than one expected output is not supported.
	ErrWrongOutputType = errors.New("chain with non string return type")
)

Functions

func BatchCall

func BatchCall(ctx context.Context, chain schema.Chain, inputs []schema.ChainValues, optFns ...func(*BatchCallOptions)) ([]schema.ChainValues, error)

BatchCall executes multiple calls to the chain.Call function concurrently and collects the results in the same order as the inputs. It utilizes the errgroup package to manage the concurrent execution and handle any errors that may occur.

func Call

func Call(ctx context.Context, chain schema.Chain, inputs schema.ChainValues, optFns ...func(*CallOptions)) (schema.ChainValues, error)

Call executes a chain with multiple inputs. It returns the outputs of the chain or an error, if any.

func SimpleCall

func SimpleCall(ctx context.Context, chain schema.Chain, input any, optFns ...func(*SimpleCallOptions)) (string, error)

SimpleCall executes a chain with a single input and a single output. It returns the output value as a string or an error, if any.

Types

type BatchCallOptions

type BatchCallOptions struct {
	Callbacks      []schema.Callback
	ParentRunID    string
	IncludeRunInfo bool
	Stop           []string
}

type CallOptions

type CallOptions struct {
	Callbacks      []schema.Callback
	ParentRunID    string
	IncludeRunInfo bool
	Stop           []string
}

type SimpleCallOptions

type SimpleCallOptions struct {
	Callbacks   []schema.Callback
	ParentRunID string
	Stop        []string
}