start beta

Author: devalexandre

.idea/.gitignore

@@ -0,0 +1,204 @@
+package langsmithgo
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/tmc/langchaingo/llms"
+	"github.com/tmc/langchaingo/llms/openai"
+)
+
+func TestMain(m *testing.M) {
+	m.Run()
+
+}
+func TestRun(t *testing.T) {
+	t.Run("use with GenerateFromSinglePrompt", func(t *testing.T) {
+		t.Skip()
+		// Create a new client
+		runId := uuid.New().String()
+		log.Println("runId: ", runId)
+		client := NewClient("")
+		prompt := "The first man to walk on the moon"
+		llm, err := openai.New()
+		if err != nil {
+			t.Errorf("Error creating LLM: %v", err)
+		}
+		ctx := context.Background()
+		err = client.Run(&RunPayload{
+			Name:        "langsmithgo-chain",
+			SessionName: "langsmithgo",
+			RunType:     Chain,
+			RunID:       runId,
+			Inputs: map[string]interface{}{
+				"prompt": prompt,
+			},
+		})
+
+		if err != nil {
+			t.Errorf("Error running: %v", err)
+		}
+
+		completion, err := llms.GenerateFromSinglePrompt(ctx,
+			llm,
+			prompt,
+			llms.WithTemperature(0.8),
+			llms.WithStopWords([]string{"Armstrong"}),
+		)
+		if err != nil {
+			log.Fatalf("error generating completion: %v", err)
+		}
+
+		err = client.Run(&RunPayload{
+			RunID: runId,
+			Outputs: map[string]interface{}{
+				"output": completion,
+			},
+		})
+
+		if err != nil {
+			t.Errorf("Error running: %v", err)
+		}
+
+		fmt.Println(completion)
+	})
+
+	t.Run("use with Chain", func(t *testing.T) {
+		t.Skip()
+		// Create a new client
+		runId := uuid.New().String()
+		client := NewClient("")
+
+		opts := []openai.Option{
+			openai.WithModel("gpt-3.5-turbo"),
+		}
+		llm, err := openai.New(opts...)
+		if err != nil {
+			t.Errorf("Error creating LLM: %v", err)
+		}
+		ctx := context.Background()
+
+		content := []llms.MessageContent{
+			llms.TextParts(llms.ChatMessageTypeSystem, "You are a company branding design wizard."),
+			llms.TextParts(llms.ChatMessageTypeHuman, "What would be a good company name a company that makes colorful socks?"),
+		}
+
+		err = client.Run(&RunPayload{
+			Name:        "langsmithgo-llm",
+			SessionName: "langsmithgo",
+			RunType:     LLM,
+			RunID:       runId,
+			Tags:        []string{"llm"},
+			Inputs: map[string]interface{}{
+				"prompt":      content, // Ensure 'output' is properly defined and is of type that has a String method
+				"model":       "gpt-3.5-turbo",
+				"temperature": 0.7, // Assuming 'temperature' should be a float, not a string
+			},
+		})
+
+		if err != nil {
+			t.Errorf("Error running: %v", err)
+		}
+
+		out, err := llm.GenerateContent(ctx, content)
+		if err != nil {
+			t.Errorf("Error running: %v", err)
+		}
+		err = client.Run(&RunPayload{
+			ParentID: runId,
+			Outputs: map[string]interface{}{
+				"output": out,
+			},
+		})
+
+		if err != nil {
+			t.Errorf("Error running: %v", err)
+		}
+
+	})
+
+	// use 2 chains
+	t.Run("use with 2 traces", func(t *testing.T) {
+		// Create a new client
+		runId := uuid.New().String()
+		client := NewClient("")
+
+		opts := []openai.Option{
+			openai.WithModel("gpt-3.5-turbo-0125"),
+			openai.WithEmbeddingModel("text-embedding-3-large"),
+		}
+		llm, err := openai.New(opts...)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		ctx := context.Background()
+
+		content := []llms.MessageContent{
+			llms.TextParts(llms.ChatMessageTypeSystem, "You are a company branding design wizard."),
+			llms.TextParts(llms.ChatMessageTypeHuman, "What would be a good company name a company that makes colorful socks?"),
+		}
+
+		err = client.Run(&RunPayload{
+			Name:        "langsmithgo-llm",
+			SessionName: "langsmithgo",
+			RunType:     LLM,
+			RunID:       runId,
+			Tags:        []string{"llm"},
+			Inputs: map[string]interface{}{
+				"prompt":      content, // Ensure 'output' is properly defined and is of type that has a String method
+				"model":       "gpt-3.5-turbo",
+				"temperature": 0.7, // Assuming 'temperature' should be a float, not a string
+			},
+		})
+
+		if err != nil {
+			t.Errorf("Error running: %v", err)
+		}
+
+		out, err := llm.GenerateContent(ctx, content)
+		if err != nil {
+			t.Errorf("Error running: %v", err)
+
+		}
+
+		err = client.Run(&RunPayload{
+			RunID: runId,
+			Outputs: map[string]interface{}{
+				"output": out,
+			},
+		})
+
+		embdId := uuid.New().String()
+		// create embedding
+		err = client.Run(&RunPayload{
+			Name:        "langsmithgo-llm",
+			SessionName: "langsmithgo",
+			RunType:     Embedding,
+			RunID:       embdId,
+			ParentID:    runId,
+			Tags:        []string{"llm"},
+			Inputs: map[string]interface{}{
+				"prompt":      out.Choices[0].Content, // Ensure 'output' is properly defined and is of type that has a String method
+				"model":       "gpt-3.5-turbo",
+				"temperature": 0.7, // Assuming 'temperature' should be a float, not a string
+			},
+		})
+		embedings, err := llm.CreateEmbedding(ctx, []string{"ola", "mundo"})
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		err = client.Run(&RunPayload{
+			RunID: embdId,
+			Outputs: map[string]interface{}{
+				"output": embedings,
+			},
+		})
+
+	})
+
+}

.idea/langsmithgo.iml

@@ -0,0 +1,114 @@
+package langsmithgo
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"regexp"
+	"time"
+)
+
+func NewClient(apiKey string) *Client {
+	apikey := apiKey
+	if apikey == "" {
+		apikey = os.Getenv("LANGSMITH_API_KEY")
+	}
+	return &Client{
+		APIKey: apiKey,
+	}
+}
+
+func (c *Client) PostRun(input *RunPayload) error {
+
+	payload := PostPayload{
+		ID:          input.RunID,
+		Name:        input.Name,
+		RunType:     input.RunType,
+		StartTime:   time.Now().UTC(),
+		Inputs:      input.Inputs,
+		SessionName: input.SessionName,
+		Tags:        input.Tags,
+		ParentId:    input.ParentID,
+		Extras:      input.Extras,
+		Metadata:    input.Metadata,
+	}
+
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+	err = c.Do(BASE_URL, http.MethodPost, jsonData)
+
+	return err
+}
+
+func (c *Client) PatchRun(id string, input *RunPayload) error {
+	payload := PatchPayload{
+		Outputs: input.Outputs,
+		EndTime: time.Now().UTC(),
+		Events:  input.Events,
+	}
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+	err = c.Do(BASE_URL+"/"+id, http.MethodPatch, jsonData)
+
+	return err
+}
+
+func (c *Client) Run(input *RunPayload) error {
+
+	uuidRegex := `^[a-f\d]{8}-[a-f\d]{4}-[a-f\d]{4}-[a-f\d]{4}-[a-f\d]{12}$`
+	match, _ := regexp.MatchString(uuidRegex, input.RunID)
+	if !match {
+		return fmt.Errorf("invalid UUID format: %s", input.RunID)
+	}
+
+	if input.Outputs != nil {
+		return c.PatchRun(input.RunID, input)
+	}
+
+	return c.PostRun(input)
+
+}
+
+// client for http requests
+func (c *Client) Do(url string, method string, jsonData []byte) error {
+	req, err := http.NewRequest(method, url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		panic(err)
+	}
+
+	// Set the necessary headers
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("x-api-key", c.APIKey)
+
+	// Create an HTTP client and send the request
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	// print a response body for human readability
+
+	// Check the response status
+	if resp.StatusCode >= 400 {
+		body, _ := io.ReadAll(resp.Body)
+		var response Response
+		err = json.Unmarshal(body, &response)
+		if err != nil {
+			return err
+		}
+
+		return errors.New(response.Detail)
+	}
+
+	return nil
+}