Prompts: Add Save and FromFile functions to serialize/deserialize prompts to disk

load/dump.go

@@ -0,0 +1,66 @@
+package load
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+var (
+	ErrInvalidFileSuffix = errors.New("invalid file suffix")
+	ErrNoDataToSerialize = errors.New("no data to serialize")
+)
+
+func (s *FileSerializer) ToFile(data any, path string) error {
+	if path == "" {
+		return ErrInvalidSavePath
+	}
+
+	if reflect.ValueOf(data).IsZero() {
+		return ErrNoDataToSerialize
+	}
+
+	suffix := s.FileSystem.NormalizeSuffix(path)
+	switch strings.ToLower(suffix) {
+	case ".json":
+		return s.toJSON(data, path)
+	case ".yaml", ".yml":
+		return s.toYAML(data, path)
+	case "":
+		return s.toJSON(data, path+".json")
+	default:
+		return fmt.Errorf("%w:%s", ErrInvalidFileSuffix, suffix)
+	}
+}
+
+func (s *FileSerializer) toJSON(d any, path string) error {
+	data, err := json.Marshal(d)
+	if err != nil {
+		return fmt.Errorf("failed to serialize JSON: %w", err)
+	}
+
+	err = s.FileSystem.Write(path, data)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *FileSerializer) toYAML(d any, path string) error {
+	data, err := yaml.Marshal(d)
+	if err != nil {
+		return fmt.Errorf("failed to serialize YAML: %w", err)
+	}
+
+	err = s.FileSystem.Write(path, data)
+	if err != nil {
+		return fmt.Errorf("failed to write to file: %w", err)
+	}
+
+	return nil
+}

load/filesystem.go

@@ -0,0 +1,75 @@
+package load
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+var (
+	ErrWritingToFile   = errors.New("error writing to file")
+	ErrInvalidSavePath = errors.New("invalid save path")
+)
+
+const filePermission = 0o600
+
+type FileSystem interface {
+	Write(path string, data []byte) error
+	Read(path string) ([]byte, error)
+	NormalizeSuffix(path string) string
+}
+
+type LocalFileSystem struct {
+	FS FileSystem
+}
+
+func (f *LocalFileSystem) Write(path string, data []byte) error {
+	absPath, err := filepath.Abs(path)
+	if err != nil {
+		return fmt.Errorf("failed to get absolute path: %w", err)
+	}
+
+	err = f.makeDirectoriesIfNeeded(absPath)
+	if err != nil {
+		return err
+	}
+
+	err = os.WriteFile(absPath, data, filePermission)
+	if err != nil {
+		return fmt.Errorf("failed writing to file: %w", err)
+	}
+
+	return nil
+}
+
+func (f *LocalFileSystem) Read(path string) ([]byte, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file: %w", err)
+	}
+	defer file.Close()
+
+	byteData, err := io.ReadAll(file)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read file: %w", err)
+	}
+
+	return byteData, nil
+}
+
+func (f *LocalFileSystem) makeDirectoriesIfNeeded(absPath string) error {
+	if _, err := os.Stat(absPath); os.IsNotExist(err) {
+		dir := filepath.Dir(absPath)
+		err := os.MkdirAll(dir, os.ModePerm)
+		if err != nil {
+			return fmt.Errorf("failed to create path directories: %w", err)
+		}
+	}
+	return nil
+}
+
+func (f *LocalFileSystem) NormalizeSuffix(path string) string {
+	return filepath.Ext(path)
+}

load/load.go

@@ -0,0 +1,56 @@
+package load
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+var ErrInvalidPath = errors.New("invalid file path")
+
+func (s *FileSerializer) FromFile(data any, path string) error {
+	if path == "" {
+		return ErrInvalidPath
+	}
+
+	suffix := s.FileSystem.NormalizeSuffix(path)
+	switch strings.ToLower(suffix) {
+	case ".json":
+		return s.fromJSON(data, path)
+	case ".yaml", ".yml":
+		return s.fromYAML(data, path)
+	default:
+		return fmt.Errorf("%w:%s", ErrInvalidPath, suffix)
+	}
+}
+
+func (s *FileSerializer) fromJSON(data any, path string) error {
+	byteData, err := s.FileSystem.Read(path)
+	if err != nil {
+		return err
+	}
+
+	err = json.Unmarshal(byteData, data)
+	if err != nil {
+		return fmt.Errorf("failed to deserialize JSON: %w", err)
+	}
+
+	return nil
+}
+
+func (s *FileSerializer) fromYAML(data any, path string) error {
+	byteData, err := s.FileSystem.Read(path)
+	if err != nil {
+		return err
+	}
+
+	err = yaml.Unmarshal(byteData, data)
+	if err != nil {
+		return fmt.Errorf("failed to deserialize JSON: %w", err)
+	}
+
+	return nil
+}

load/serialization.go

@@ -0,0 +1,16 @@
+package load
+
+type Serializer interface {
+	ToFile(data any, path string) error
+	FromFile(data any, path string) error
+}
+
+type FileSerializer struct {
+	FileSystem FileSystem
+}
+
+func NewSerializer(fs FileSystem) *FileSerializer {
+	return &FileSerializer{
+		FileSystem: fs,
+	}
+}

prompts/chat_prompt_template.go

@@ -1,15 +1,17 @@
 package prompts
 
-import "github.com/tmc/langchaingo/schema"
+import (
+	"github.com/tmc/langchaingo/load"
+	"github.com/tmc/langchaingo/schema"
+)
 
 // ChatPromptTemplate is a prompt template for chat messages.
 type ChatPromptTemplate struct {
 	// Messages is the list of the messages to be formatted.
-	Messages []MessageFormatter
-
+	Messages []MessageFormatter `json:"messages"`
 	// PartialVariables represents a map of variable names to values or functions that return values.
 	// If the value is a function, it will be called when the prompt template is rendered.
-	PartialVariables map[string]any
+	PartialVariables map[string]any `json:"partial_variables"`
 }
 
 var (
@@ -66,6 +68,17 @@ func (p ChatPromptTemplate) GetInputVariables() []string {
 	return inputVariables
 }
 
+func (p ChatPromptTemplate) Save(path string, serializer load.Serializer) error {
+	if p.PartialVariables != nil {
+		return ErrPromptTemplateCannotBeSaved
+	}
+	err := serializer.ToFile(p, path)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 // NewChatPromptTemplate creates a new chat prompt template from a list of message formatters.
 func NewChatPromptTemplate(messages []MessageFormatter) ChatPromptTemplate {
 	return ChatPromptTemplate{

prompts/chat_prompt_template_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/tmc/langchaingo/load"
 	"github.com/tmc/langchaingo/schema"
 )
 
@@ -43,3 +44,92 @@ func TestChatPromptTemplate(t *testing.T) {
 	})
 	assert.Error(t, err)
 }
+
+func TestChatPromptTemplateTypesSaveToFile(t *testing.T) {
+	t.Parallel()
+	humanMessagePrompt := NewHumanMessagePromptTemplate(
+		`translate this text from {{.inputLang}} to {{.outputLang}}:\n{{.input}}`,
+		[]string{"inputLang", "outputLang", "input"})
+
+	systemMessagePrompt := NewSystemMessagePromptTemplate(
+		"You are a translation engine that can only translate text and cannot interpret it.",
+		nil)
+
+	type args struct {
+		path     string
+		template MessageFormatter
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{"with_JSON_suffix", args{"", humanMessagePrompt}, true},
+		{"with_JSON_suffix", args{"", systemMessagePrompt}, true},
+		{"with_JSON_suffix", args{"_human_prompt_with_JSON_suffix.json", humanMessagePrompt}, false},
+		{"with_JSON_suffix", args{"_system_prompt_with_JSON_suffix.json", systemMessagePrompt}, false},
+		{"with_YAML_suffix", args{"human_prompt_with_YAML_suffix.yaml", humanMessagePrompt}, false},
+		{"with_YAML_suffix", args{"system_prompt_with_YAML_suffix.yaml", systemMessagePrompt}, false},
+		{"case_sensitive", args{"human_prompt_case_sensitive.Yaml", humanMessagePrompt}, false},
+		{"case_sensitive", args{"system_prompt_case_sensitive.Yaml", systemMessagePrompt}, false},
+		{"no_suffix", args{"human_prompt_no_suffix", humanMessagePrompt}, false},
+		{"no_suffix", args{"system_prompt_no_suffix", systemMessagePrompt}, false},
+		{"invalid_suffix", args{"human_prompt.", humanMessagePrompt}, true},
+		{"invalid_suffix", args{"system_prompt.", systemMessagePrompt}, true},
+		{"absolute_path_JSON_suffix", args{"/human_prompt_absolute_path_JSON_suffix.json", humanMessagePrompt}, false},
+		{"absolute_path_JSON_suffix", args{"/system_prompt_absolute_path_JSON_suffix.json", systemMessagePrompt}, false},
+		{"relative_path_no_suffix", args{"prompts/human_prompt_relative_path_no_suffix", humanMessagePrompt}, false},
+		{"relative_path_no_suffix", args{"prompts/system_prompt_relative_path_no_suffix", systemMessagePrompt}, false},
+	}
+	fileSystem := &MockFileSystem{
+		Storage: make(map[string][]byte, 0),
+	}
+	serializer := load.NewSerializer(fileSystem)
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			err := tt.args.template.Save(tt.args.path, serializer)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("PromptTemplate.Save() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+		})
+	}
+}
+
+func TestHumanMessagePromptTemplateReadFromFile(t *testing.T) {
+	t.Parallel()
+	expectedPrompt := NewHumanMessagePromptTemplate(
+		`translate this text from {{.inputLang}} to {{.outputLang}}:\n{{.input}}`,
+		[]string{"inputLang", "outputLang", "input"})
+
+	fileSystem := &MockFileSystem{
+		Storage: make(map[string][]byte, 0),
+	}
+	serializer := load.NewSerializer(fileSystem)
+	err := expectedPrompt.Save("prompt_data.json", serializer)
+	assert.NoError(t, err)
+
+	prompt, err := NewHumanMessagePromptFromFile("prompt_data.json", serializer)
+	assert.NoError(t, err)
+	assert.EqualValues(t, prompt, expectedPrompt)
+}
+
+func TestSystemMessagePromptTemplateSave(t *testing.T) {
+	t.Parallel()
+	expectedPrompt := NewSystemMessagePromptTemplate(
+		"You are a translation engine that can only translate text and cannot interpret it.",
+		nil)
+
+	fileSystem := &MockFileSystem{
+		Storage: make(map[string][]byte, 0),
+	}
+	serializer := load.NewSerializer(fileSystem)
+	err := expectedPrompt.Save("prompt_data.json", serializer)
+	assert.NoError(t, err)
+
+	prompt, err := NewSystemMessagePromptFromFile("prompt_data.json", serializer)
+	assert.NoError(t, err)
+	assert.EqualValues(t, prompt, expectedPrompt)
+}