Go SDK

go get github.com/engramma/engramma-go

package main

import (
	"os"

	engramma "github.com/engramma/engramma-go"
)

func main() {
	client := engramma.NewClient(os.Getenv("ENGRAMMA_API_KEY"))
}

ctx := context.Background()

result, err := client.Text.Store(ctx, &engramma.StoreRequest{
	Text:     "The deployment window is Tuesday 2-4pm UTC",
	Metadata: map[string]interface{}{"category": "ops", "priority": "high"},
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Pattern ID: %s\n", result.PatternID)
fmt.Printf("Embedding dim: %d\n", result.EmbeddingDim)
fmt.Printf("Patterns used: %d / %d\n", result.PatternsUsed, result.PatternsLimit)

results, err := client.Text.BatchStore(ctx, []engramma.StoreRequest{
	{Text: "Alice joined the team on Jan 5"},
	{Text: "Project deadline is March 15", Metadata: map[string]interface{}{"priority": "high"}},
	{Text: "Budget approved for Q2", Metadata: map[string]interface{}{"dept": "finance"}},
})
if err != nil {
	log.Fatal(err)
}
for _, r := range results.Items {
	fmt.Printf("Stored: %s\n", r.PatternID)
}

results, err := client.Text.Retrieve(ctx, &engramma.RetrieveRequest{
	Query: "When can we deploy?",
	TopK:  5,
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Latency: %dms\n", results.LatencyMs)
for _, r := range results.Results {
	fmt.Printf("%s (similarity: %.4f, id: %s)\n", r.Text, r.Similarity, r.PatternID)
}

results, err := client.Text.Recall(ctx, &engramma.RecallRequest{
	Query:          "What happened before the outage?",
	TemporalWeight: 0.8,
	CausalWeight:   0.7,
	Limit:          10,
})
if err != nil {
	log.Fatal(err)
}
for _, r := range results.Results {
	fmt.Printf("%s (similarity: %.4f)\n", r.Text, r.Similarity)
}

explanation, err := client.Text.Explain(ctx, &engramma.ExplainRequest{
	Query: "When can we deploy?",
	Lang:  "en", // "en" or "fr"
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(explanation.Explanation)
fmt.Printf("Method: %s\n", explanation.Method)
fmt.Printf("Confidence: %.2f\n", explanation.Confidence)

err := client.Text.Forget(ctx, &engramma.ForgetRequest{
	Query:     "deployment window",
	Category:  "ops",
	Threshold: 0.85,
})
if err != nil {
	log.Fatal(err)
}

stats, err := client.Text.Stats(ctx)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Total patterns: %d\n", stats.TotalPatterns)
fmt.Printf("Storage used: %d bytes\n", stats.StorageBytes)

result, err := client.Consolidation.Sleep(ctx, &engramma.SleepRequest{
	Mode: "full", // "full" or "light"
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Consolidation started: %s\n", result.Status)

status, err := client.Consolidation.Status(ctx)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("State: %s\n", status.State)
fmt.Printf("Progress: %.0f%%\n", status.Progress*100)

regime, err := client.Regime.Current(ctx)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Current regime: %s\n", regime.Mode)

result, err := client.Causal.Strength(ctx, &engramma.CausalStrengthRequest{
	Source: "deployment",
	Target: "outage",
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Causal strength: %.4f\n", result.Strength)

result, err := client.Causal.Neighbors(ctx, &engramma.CausalNeighborsRequest{
	Concept: "deployment",
	TopK:    10,
})
if err != nil {
	log.Fatal(err)
}
for _, n := range result.Neighbors {
	fmt.Printf("%s (strength: %.4f)\n", n.Concept, n.Strength)
}

// Timeout per request
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
result, err := client.Text.Retrieve(ctx, &engramma.RetrieveRequest{Query: "test"})

// Cancellation
ctx, cancel := context.WithCancel(context.Background())
go func() {
	time.Sleep(2 * time.Second)
	cancel() // cancels the in-flight request
}()
result, err := client.Text.Retrieve(ctx, &engramma.RetrieveRequest{Query: "test"})
if errors.Is(err, context.Canceled) {
	fmt.Println("Request was cancelled")
}

// Pass trace IDs from HTTP handlers
func handler(w http.ResponseWriter, r *http.Request) {
	result, err := client.Text.Retrieve(r.Context(), &engramma.RetrieveRequest{
		Query: "deployment schedule",
	})
}

import "github.com/engramma/engramma-go/errors"

result, err := client.Text.Retrieve(ctx, &engramma.RetrieveRequest{Query: "test"})
if err != nil {
	var apiErr *errors.APIError
	if stderrors.As(err, &apiErr) {
		switch apiErr.StatusCode {
		case 401:
			fmt.Println("Invalid API key")
		case 429:
			fmt.Printf("Rate limited. Retry after %ds\n", apiErr.RetryAfter)
		case 404:
			fmt.Println("Resource not found")
		default:
			fmt.Printf("API error %d: %s\n", apiErr.StatusCode, apiErr.Message)
		}
	} else {
		fmt.Printf("Network error: %v\n", err)
	}
}

// Concurrent stores
var wg sync.WaitGroup
facts := []string{"Fact A", "Fact B", "Fact C", "Fact D"}

for _, fact := range facts {
	wg.Add(1)
	go func(text string) {
		defer wg.Done()
		_, err := client.Text.Store(ctx, &engramma.StoreRequest{Text: text})
		if err != nil {
			log.Printf("Failed to store: %v", err)
		}
	}(fact)
}
wg.Wait()

// Using errgroup for error propagation
g, ctx := errgroup.WithContext(ctx)
for _, fact := range facts {
	g.Go(func() error {
		_, err := client.Text.Store(ctx, &engramma.StoreRequest{Text: fact})
		return err
	})
}
if err := g.Wait(); err != nil {
	log.Fatal(err)
}

client := engramma.NewClient(
	"nx_live_...",
	engramma.WithMaxRetries(5),
	engramma.WithRetryBackoff(2.0),
	engramma.WithRetryMaxWait(30 * time.Second),
)

// Pointer helpers for optional fields
engramma.Float64(0.9)   // *float64
engramma.String("val")  // *string
engramma.Int(5)         // *int
engramma.Bool(true)     // *bool