embeddings: remove TEI embeddings client.

.github/workflows/ci.yaml

@@ -18,9 +18,10 @@ jobs:
           cache: false
       - uses: actions/checkout@v3
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3.6.0
+        uses: golangci/golangci-lint-action@v3.7.0
         with:
           args: --timeout=4m
+          version: v1.55.1
   build-examples:
     runs-on: ubuntu-latest
     steps:

.github/workflows/publish-docs.yaml

@@ -0,0 +1,47 @@
+name: Deploy to GitHub Pages
+
+on:
+  push: main
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  # Single deploy job since we're just deploying
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: yarn
+          cache-dependency-path: 'docs/package-lock.json'
+
+      - name: Install dependencies
+        working-directory: docs
+        run: yarn install --frozen-lockfile
+      - name: Build website
+        working-directory: docs
+        run: yarn build
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v3
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v2
+        with:
+          # Upload entire repository
+          path: 'docs/build'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v2

Makefile

@@ -7,7 +7,7 @@ test:
 	go test ./...
 
 .PHONY: lint
-lint:
+lint: lint-deps
 	golangci-lint run --color=always --sort-results ./...
 
 .PHONY: lint-exp
@@ -22,6 +22,13 @@ lint-fix:
 lint-all:
 	golangci-lint run --color=always --sort-results ./...
 
+.PHONY: lint-deps
+lint-deps:
+	@command -v golangci-lint >/dev/null 2>&1 || { \
+		echo >&2 "golangci-lint not found. Installing..."; \
+		go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.55.1; \
+	}
+
 .PHONY: test-race
 test-race:
 	go run test -race ./...
@@ -45,3 +52,8 @@ clean-lint-cache:
 build-examples:
 	for example in $(shell find ./examples -mindepth 1 -maxdepth 1 -type d); do \
 		(cd $$example; echo Build $$example; go mod tidy; go build -o /dev/null) || exit 1; done
+
+.PHONY: add-go-work
+add-go-work:
+	go work init .
+	go work use -r .

README.md

@@ -2,17 +2,22 @@
 
 [![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/tmc/langchaingo)
 [![scorecard](https://goreportcard.com/badge/github.com/tmc/langchaingo)](https://goreportcard.com/report/github.com/tmc/langchaingo)
+[![](https://dcbadge.vercel.app/api/server/2NgDkQDjpQ?compact=true&style=flat)](https://discord.gg/2NgDkQDjpQ)
+[![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/tmc/langchaingo)
+[<img src="https://github.com/codespaces/badge.svg" title="Open in Github Codespace" width="150" height="20">](https://codespaces.new/tmc/langchaingo)
 
-⚡ Building applications with LLMs through composability ⚡
+⚡ Building applications with LLMs through composability, with Go! ⚡
 
 ## 🤔 What is this?
 
 This is the Go language implementation of LangChain.
 
 ## 📖 Documentation
 
+- [Documentation Site](https://tmc.github.io/langchaingo/docs/)
 - [API Reference](https://pkg.go.dev/github.com/tmc/langchaingo)
 
+
 ## 🎉 Examples
 
 See [./examples](./examples) for example usage.
@@ -51,5 +56,6 @@ Socktastic!
 
 Here are some links to blog posts and articles on using Langchain Go:
 
-- [Creating a simple ChatGPT clone with Go](https://sausheong.com/creating-a-simple-chatgpt-clone-with-go-c40b4bec9267?sk=53a2bcf4ce3b0cfae1a4c26897c0deb0)
-- [Creating a ChatGPT Clone that Runs on Your Laptop with Go](https://sausheong.com/creating-a-chatgpt-clone-that-runs-on-your-laptop-with-go-bf9d41f1cf88?sk=05dc67b60fdac6effb1aca84dd2d654e)
+- [Using Ollama with LangChainGo](https://eli.thegreenplace.net/2023/using-ollama-with-langchaingo/) - Nov 2023
+- [Creating a simple ChatGPT clone with Go](https://sausheong.com/creating-a-simple-chatgpt-clone-with-go-c40b4bec9267?sk=53a2bcf4ce3b0cfae1a4c26897c0deb0) - Aug 2023
+- [Creating a ChatGPT Clone that Runs on Your Laptop with Go](https://sausheong.com/creating-a-chatgpt-clone-that-runs-on-your-laptop-with-go-bf9d41f1cf88?sk=05dc67b60fdac6effb1aca84dd2d654e) - Aug 2023

agents/conversational.go

@@ -6,6 +6,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/tmc/langchaingo/callbacks"
 	"github.com/tmc/langchaingo/chains"
 	"github.com/tmc/langchaingo/llms"
 	"github.com/tmc/langchaingo/schema"
@@ -31,6 +32,8 @@ type ConversationalAgent struct {
 	Tools []tools.Tool
 	// Output key is the key where the final output is placed.
 	OutputKey string
+	// CallbacksHandler is the handler for callbacks.
+	CallbacksHandler callbacks.Handler
 }
 
 var _ Agent = (*ConversationalAgent)(nil)
@@ -42,9 +45,10 @@ func NewConversationalAgent(llm llms.LanguageModel, tools []tools.Tool, opts ...
 	}
 
 	return &ConversationalAgent{
-		Chain:     chains.NewLLMChain(llm, options.getConversationalPrompt(tools)),
-		Tools:     tools,
-		OutputKey: options.outputKey,
+		Chain:            chains.NewLLMChain(llm, options.getConversationalPrompt(tools)),
+		Tools:            tools,
+		OutputKey:        options.outputKey,
+		CallbacksHandler: options.callbacksHandler,
 	}
 }
 
@@ -61,11 +65,21 @@ func (a *ConversationalAgent) Plan(
 
 	fullInputs["agent_scratchpad"] = constructScratchPad(intermediateSteps)
 
+	var stream func(ctx context.Context, chunk []byte) error
+
+	if a.CallbacksHandler != nil {
+		stream = func(ctx context.Context, chunk []byte) error {
+			a.CallbacksHandler.HandleStreamingFunc(ctx, chunk)
+			return nil
+		}
+	}
+
 	output, err := chains.Predict(
 		ctx,
 		a.Chain,
 		fullInputs,
 		chains.WithStopWords([]string{"\nObservation:", "\n\tObservation:"}),
+		chains.WithStreamingFunc(stream),
 	)
 	if err != nil {
 		return nil, nil, err
@@ -110,12 +124,14 @@ func (a *ConversationalAgent) parseOutput(output string) ([]schema.AgentAction,
 	if strings.Contains(output, _conversationalFinalAnswerAction) {
 		splits := strings.Split(output, _conversationalFinalAnswerAction)
 
-		return nil, &schema.AgentFinish{
+		finishAction := &schema.AgentFinish{
 			ReturnValues: map[string]any{
 				a.OutputKey: splits[len(splits)-1],
 			},
 			Log: output,
-		}, nil
+		}
+
+		return nil, finishAction, nil
 	}
 
 	r := regexp.MustCompile(`Action: (.*?)[\n]*Action Input: (.*)`)

agents/conversational_test.go

@@ -19,7 +19,7 @@ func TestConversationalWithMemory(t *testing.T) {
 		t.Skip("OPENAI_API_KEY not set")
 	}
 
-	llm, err := openai.New()
+	llm, err := openai.New(openai.WithModel("gpt-4"))
 	require.NoError(t, err)
 
 	executor, err := Initialize(

agents/errors.go

@@ -17,7 +17,24 @@ var (
 
 	// ErrUnableToParseOutput is returned if the output of the llm is unparsable.
 	ErrUnableToParseOutput = errors.New("unable to parse agent output")
-	// ErrInvalidChainReturnType is returned if the internal chain of the agent eturns a value in the
+	// ErrInvalidChainReturnType is returned if the internal chain of the agent returns a value in the
 	// "text" filed that is not a string.
 	ErrInvalidChainReturnType = errors.New("agent chain did not return a string")
 )
+
+// ParserErrorHandler is the struct used to handle parse errors from the agent in the executor. If
+// an executor have a ParserErrorHandler, parsing errors will be formatted using the formatter
+// function and added as an observation. In the next executor step the agent will then have the
+// possibility to fix the error.
+type ParserErrorHandler struct {
+	// The formatter function can be used to format the parsing error. If nil the error will be given
+	// as an observation directly.
+	Formatter func(err string) string
+}
+
+// NewParserErrorHandler creates a new parser error handler.
+func NewParserErrorHandler(formatFunc func(string) string) *ParserErrorHandler {
+	return &ParserErrorHandler{
+		Formatter: formatFunc,
+	}
+}

agents/executor.go

@@ -2,6 +2,7 @@ package agents
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -19,6 +20,7 @@ type Executor struct {
 	Tools            []tools.Tool
 	Memory           schema.Memory
 	CallbacksHandler callbacks.Handler
+	ErrorHandler     *ParserErrorHandler
 
 	MaxIterations           int
 	ReturnIntermediateSteps bool
@@ -43,6 +45,7 @@ func NewExecutor(agent Agent, tools []tools.Tool, opts ...CreationOption) Execut
 		MaxIterations:           options.maxIterations,
 		ReturnIntermediateSteps: options.returnIntermediateSteps,
 		CallbacksHandler:        options.callbacksHandler,
+		ErrorHandler:            options.errorHandler,
 	}
 }
 
@@ -55,28 +58,56 @@ func (e Executor) Call(ctx context.Context, inputValues map[string]any, _ ...cha
 
 	steps := make([]schema.AgentStep, 0)
 	for i := 0; i < e.MaxIterations; i++ {
-		actions, finish, err := e.Agent.Plan(ctx, steps, inputs)
-		if err != nil {
-			return nil, err
+		var finish map[string]any
+		steps, finish, err = e.doIteration(ctx, steps, nameToTool, inputs)
+		if finish != nil || err != nil {
+			return finish, err
 		}
+	}
 
-		if len(actions) == 0 && finish == nil {
-			return nil, ErrAgentNoReturn
-		}
+	return e.getReturn(
+		&schema.AgentFinish{ReturnValues: make(map[string]any)},
+		steps,
+	), ErrNotFinished
+}
 
-		if finish != nil {
-			return e.getReturn(finish, steps), nil
+func (e Executor) doIteration(
+	ctx context.Context,
+	steps []schema.AgentStep,
+	nameToTool map[string]tools.Tool,
+	inputs map[string]string,
+) ([]schema.AgentStep, map[string]any, error) {
+	actions, finish, err := e.Agent.Plan(ctx, steps, inputs)
+	if errors.Is(err, ErrUnableToParseOutput) && e.ErrorHandler != nil {
+		formattedObservation := err.Error()
+		if e.ErrorHandler.Formatter != nil {
+			formattedObservation = e.ErrorHandler.Formatter(formattedObservation)
 		}
+		steps = append(steps, schema.AgentStep{
+			Observation: formattedObservation,
+		})
+		return steps, nil, nil
+	}
+	if err != nil {
+		return steps, nil, err
+	}
+
+	if len(actions) == 0 && finish == nil {
+		return steps, nil, ErrAgentNoReturn
+	}
 
-		for _, action := range actions {
-			steps, err = e.doAction(ctx, steps, nameToTool, action)
-			if err != nil {
-				return nil, err
-			}
+	if finish != nil {
+		return steps, e.getReturn(finish, steps), nil
+	}
+
+	for _, action := range actions {
+		steps, err = e.doAction(ctx, steps, nameToTool, action)
+		if err != nil {
+			return steps, nil, err
 		}
 	}
 
-	return nil, ErrNotFinished
+	return steps, nil, nil
 }
 
 func (e Executor) doAction(

agents/executor_test.go

@@ -10,11 +10,66 @@ import (
 	"github.com/tmc/langchaingo/agents"
 	"github.com/tmc/langchaingo/chains"
 	"github.com/tmc/langchaingo/llms/openai"
+	"github.com/tmc/langchaingo/schema"
 	"github.com/tmc/langchaingo/tools"
 	"github.com/tmc/langchaingo/tools/serpapi"
 )
 
-func TestMRKL(t *testing.T) {
+type testAgent struct {
+	actions    []schema.AgentAction
+	finish     *schema.AgentFinish
+	err        error
+	inputKeys  []string
+	outputKeys []string
+
+	recordedIntermediateSteps []schema.AgentStep
+	recordedInputs            map[string]string
+	numPlanCalls              int
+}
+
+func (a *testAgent) Plan(
+	_ context.Context,
+	intermediateSteps []schema.AgentStep,
+	inputs map[string]string,
+) ([]schema.AgentAction, *schema.AgentFinish, error) {
+	a.recordedIntermediateSteps = intermediateSteps
+	a.recordedInputs = inputs
+	a.numPlanCalls++
+
+	return a.actions, a.finish, a.err
+}
+
+func (a testAgent) GetInputKeys() []string {
+	return a.inputKeys
+}
+
+func (a testAgent) GetOutputKeys() []string {
+	return a.outputKeys
+}
+
+func TestExecutorWithErrorHandler(t *testing.T) {
+	t.Parallel()
+
+	a := &testAgent{
+		err: agents.ErrUnableToParseOutput,
+	}
+	executor := agents.NewExecutor(
+		a,
+		nil,
+		agents.WithMaxIterations(3),
+		agents.WithParserErrorHandler(agents.NewParserErrorHandler(nil)),
+	)
+
+	_, err := chains.Call(context.Background(), executor, nil)
+	require.ErrorIs(t, err, agents.ErrNotFinished)
+	require.Equal(t, 3, a.numPlanCalls)
+	require.Equal(t, []schema.AgentStep{
+		{Observation: agents.ErrUnableToParseOutput.Error()},
+		{Observation: agents.ErrUnableToParseOutput.Error()},
+	}, a.recordedIntermediateSteps)
+}
+
+func TestExecutorWithMRKLAgent(t *testing.T) {
 	t.Parallel()
 
 	if openaiKey := os.Getenv("OPENAI_API_KEY"); openaiKey == "" {