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.Store(ctx, &engramma.StoreRequest{
	Text:       "The deployment window is Tuesday 2-4pm UTC",
	Metadata:   map[string]string{"category": "ops", "priority": "high"},
	Importance: engramma.Float64(0.9),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Pattern ID: %s\n", result.PatternID)
fmt.Printf("Confidence: %.2f\n", result.Confidence)

results, err := client.BatchStore(ctx, []engramma.StoreRequest{
	{Text: "Alice joined the team on Jan 5"},
	{Text: "Project deadline is March 15", Importance: engramma.Float64(0.95)},
	{Text: "Budget approved for Q2", Metadata: map[string]string{"dept": "finance"}},
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Stored %d patterns\n", results.Stored)

results, err := client.Retrieve(ctx, &engramma.RetrieveRequest{
	Query:         "When can we deploy?",
	TopK:          5,
	MinConfidence: 0.5,
	Pathway:       engramma.PathwayAuto,
})
if err != nil {
	log.Fatal(err)
}
for _, r := range results {
	fmt.Printf("%s (confidence: %.2f, pathway: %s)\n", r.Text, r.Confidence, r.Pathway)
}

results, err := client.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 {
	fmt.Printf("%s (relevance: %.2f)\n", r.Text, r.RelevanceScore)
}

explanation, err := client.Explain(ctx, &engramma.ExplainRequest{
	Query: "When can we deploy?",
	Level: engramma.LevelDetailed, // LevelBrief, LevelDetailed, LevelDebug
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(explanation.Summary)
fmt.Printf("Pathway scores: %+v\n", explanation.PathwayScores)

err := client.Forget(ctx, "pat_7f3a2b", &engramma.ForgetOptions{
	Soft: true, // recoverable within 30 days
})
if err != nil {
	log.Fatal(err)
}

// Search
results, err := client.Text.Search(ctx, &engramma.TextSearchRequest{
	Query:   "deployment",
	Filters: map[string]string{"category": "ops"},
	Sort:    "relevance",
	Limit:   20,
})

// Summarize
summary, err := client.Text.Summarize(ctx, &engramma.SummarizeRequest{
	Topic:     "Q1 project updates",
	MaxLength: 200,
})

// Compare
comparison, err := client.Text.Compare(ctx, "pat_abc123", "pat_def456")

// Tag
err = client.Text.Tag(ctx, "pat_abc123", []string{"important", "ops"})

// Link
err = client.Text.Link(ctx, &engramma.LinkRequest{
	SourceID: "pat_abc123",
	TargetID: "pat_def456",
	Relation: "caused_by",
})

// Timeline
timeline, err := client.Text.Timeline(ctx, &engramma.TimelineRequest{
	Topic: "deployment",
	From:  "2026-01-01",
	To:    "2026-01-31",
})

// Consolidation preview
preview, err := client.Engine.Consolidation.Preview(ctx)
fmt.Printf("Would merge: %d\n", preview.MergeCandidates)

// Trigger consolidation
result, err := client.Engine.Consolidation.Merge(ctx)
fmt.Printf("Merged: %d, Pruned: %d\n", result.Merged, result.Pruned)

// Diagnostics
err = client.Engine.Diagnostics.Prefetch(ctx, []string{"deployment", "budget"})
err = client.Engine.Diagnostics.Warmup(ctx)
structure, err := client.Engine.Diagnostics.Structure(ctx)

// Timeout per request
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
result, err := client.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.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.Retrieve(r.Context(), &engramma.RetrieveRequest{
		Query: "deployment schedule",
	})
}

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

result, err := client.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.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.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