Go SDK

pkg.go.dev · GitHub

go get github.com/dakera-ai/dakera-go@latest

Client setup

import (
    dakera "github.com/dakera-ai/dakera-go"
    "os"
    "time"
)

// Recommended: configure via env vars
// DAKERA_URL=http://<YOUR_SERVER_IP>:3300
// DAKERA_API_KEY=your-api-key

serverURL := os.Getenv("DAKERA_URL")
if serverURL == "" { serverURL = "http://localhost:3300" }

client := dakera.NewClientWithOptions(dakera.ClientOptions{
    BaseURL: serverURL,
    APIKey:  os.Getenv("DAKERA_API_KEY"),
    Timeout: 30 * time.Second,
})

Memory operations

_, err := client.Memories.Store(ctx, &dakera.StoreRequest{
    AgentID: "my-agent", Content: "User is learning Rust", Importance: 0.8, Tags: []string{"learning"},
})
memories, err := client.Memories.Recall(ctx, &dakera.RecallRequest{
    AgentID: "my-agent", Query: "programming languages", TopK: 10,
})
err = client.Memories.Forget(ctx, "mem-abc123")

Sessions

session, _ := client.Sessions.Start(ctx, &dakera.StartSessionRequest{AgentID: "my-agent"})
_, _ = client.Sessions.End(ctx, &dakera.EndSessionRequest{SessionID: session.ID, Summary: "Done"})

Vector operations

// Upsert a vector with metadata
_, err := client.Vectors.Upsert(ctx, &dakera.VectorUpsertRequest{
    Namespace: "my-namespace",
    ID:        "doc-001",
    Text:      "quarterly revenue report",
    Metadata:  map[string]any{"source": "finance"},
})

// Query vectors
results, err := client.Vectors.Query(ctx, &dakera.VectorQueryRequest{
    Namespace: "my-namespace",
    Text:      "revenue trends",
    TopK:      5,
})

Namespace management

// Create a namespace with custom settings
_, err := client.Namespaces.Create(ctx, &dakera.CreateNamespaceRequest{
    Name:       "production",
    IndexType:  "hnsw",
    Dimension: 1024,
})

// List namespaces
namespaces, err := client.Namespaces.List(ctx)

// Delete a namespace
err = client.Namespaces.Delete(ctx, "old-namespace")

Knowledge graph

// Build knowledge graph from a seed memory
graph, _ := client.Knowledge.Graph(ctx, "my-agent", "mem-abc", &dakera.KGOptions{Depth: 2})

// Cross-agent network
network, _ := client.Knowledge.CrossAgentNetwork(ctx, []string{"agent-a", "agent-b"})

// Deduplicate (preview)
dupes, _ := client.Knowledge.Deduplicate(ctx, "my-agent", &dakera.DeduplicateRequest{DryRun: true})

Full-text & hybrid search

// Index documents
client.Vectors.IndexDocuments(ctx, "docs", []dakera.Document{
    {ID: "doc-1", Text: "Quarterly revenue report"},
})

// BM25 search
results, _ := client.Vectors.FulltextSearch(ctx, "docs", "revenue", 5)

// Hybrid vector + text search
results, _ = client.Vectors.HybridSearch(ctx, &dakera.HybridRequest{
    Namespace: "docs", Text: "revenue trends", VectorWeight: 0.7,
})

Entity extraction & feedback

// Extract entities
entities, _ := client.ExtractEntities(ctx, "Alice met Bob at Google HQ", nil)

// Feedback loop
client.Memories.Feedback(ctx, "mem-abc", "upvote")
summary, _ := client.Agents.FeedbackSummary(ctx, "my-agent")

Import, export & API keys

// Export memories
data, _ := client.ExportMemories(ctx, "my-agent", "jsonl")

// Import from Mem0
client.ImportMemories(ctx, "my-agent", mem0Data, "mem0")

// Create namespace-scoped API key
key, _ := client.Namespaces.CreateKey(ctx, "production", &dakera.CreateKeyRequest{
    Name: "reader", Scope: "read", ExpiresInDays: 90,
})

Batch operations

// Batch forget — remove memories matching filters
resp, _ := client.BatchForget(ctx, dakera.BatchForgetRequest{
    AgentID: "my-agent",
    Filter:  &dakera.BatchForgetFilter{Tags: []string{"obsolete"}, MaxImportance: floatPtr(0.3)},
})
fmt.Printf("Deleted %d memories\n", resp.DeletedCount)

// Batch query text — multi-query in one call
results, _ := client.Vectors.BatchQueryText(ctx, "docs", []dakera.TextQuery{
    {Text: "revenue report", TopK: 5},
    {Text: "product roadmap", TopK: 3},
})

Health probes

// Readiness probe (dependencies healthy)
ready, _ := client.HealthReady(ctx)

// Liveness probe (process alive)
live, _ := client.HealthLive(ctx)

Vector bulk operations

// Bulk update vectors by ID
_, err := client.Vectors.BulkUpdate(ctx, "docs", []dakera.BulkUpdateItem{
    {ID: "doc-001", Metadata: map[string]any{"reviewed": true}},
})

// Bulk delete vectors by ID
_, err = client.Vectors.BulkDelete(ctx, "docs", []string{"doc-003", "doc-004"})

// Count vectors in a namespace
count, _ := client.Vectors.Count(ctx, "docs")

Full-text index management

// Get full-text index stats
stats, _ := client.Vectors.FulltextStats(ctx, "docs")
fmt.Printf("Documents: %d, Terms: %d\n", stats.DocumentCount, stats.TermCount)

// Delete a full-text document by ID
client.Vectors.FulltextDelete(ctx, "docs", "doc-001")

TTL & storage

// TTL engine stats
ttl, _ := client.TtlStats(ctx)

// Storage tier overview
tiers, _ := client.StorageTierOverview(ctx)

// Memory type stats (episodic, semantic, procedural, working)
typeStats, _ := client.MemoryTypeStats(ctx)

Agent consolidation

// Trigger consolidation for an agent
client.Agents.Consolidate(ctx, "my-agent")

// Get consolidation log
log, _ := client.Agents.ConsolidationLog(ctx, "my-agent")

// Patch consolidation config
client.Agents.PatchConsolidationConfig(ctx, "my-agent", &dakera.ConsolidationConfig{
    Threshold: floatPtr(0.9), MaxBatch: intPtr(100),
})

Namespace config

// Get entity extraction config
config, _ := client.Namespaces.GetEntityConfig(ctx, "production")

// Get namespace extractor settings
extractor, _ := client.Namespaces.GetExtractor(ctx, "production")

// Migrate namespace dimensions (e.g. 768 → 1024)
client.Namespaces.MigrateDimensions(ctx, "production", 1024)

Admin & ops

// Cluster status
cluster, _ := client.ClusterStatus(ctx)

// Maintenance mode
client.AdminEnableMaintenance(ctx, "scheduled upgrade")
client.AdminDisableMaintenance(ctx)

// Quota management
quotas, _ := client.GetQuotas(ctx)
client.UpdateQuotas(ctx, map[string]any{"max_memories_per_agent": 100000})

// Slow query log
slow, _ := client.SlowQueries(ctx, 20)

// Backups
backup, _ := client.CreateBackup(ctx, true)
backups, _ := client.ListBackups(ctx)

// Ops diagnostics
diag, _ := client.OpsDiagnostics(ctx)

// List background jobs
jobs, _ := client.OpsListJobs(ctx)

// Trigger compaction
client.OpsCompact(ctx, "production")

// Graceful shutdown
client.OpsShutdown(ctx)

Autopilot & decay (admin)

// AutoPilot status
status, _ := client.AutopilotStatus(ctx)

// Update AutoPilot config
client.AutopilotUpdateConfig(ctx, dakera.AutopilotConfigRequest{
    Enabled: boolPtr(true), DedupThreshold: floatPtr(0.93),
})

// Trigger dedup cycle
client.AutopilotTrigger(ctx, "dedup")

// Decay engine config
decay, _ := client.DecayConfig(ctx)
client.DecayUpdateConfig(ctx, dakera.DecayConfigUpdateRequest{
    HalfLifeDays: intPtr(30),
})

Memory policy

// Set memory lifecycle policy for a namespace
client.Namespaces.SetMemoryPolicy(ctx, "production", &dakera.MemoryPolicy{
    EpisodicTTLSeconds: intPtr(604800),
    WorkingTTLSeconds:  intPtr(3600),
})

// Get current policy
policy, _ := client.Namespaces.GetMemoryPolicy(ctx, "production")

SSE streaming

// Stream real-time memory events
ch, _ := client.StreamMemoryEvents(ctx)
for event := range ch {
    fmt.Printf("%s: %v\n", event.Type, event.Data)
}

Error handling

import "errors"

_, err := client.Memories.Get(ctx, "mem-abc")
if err != nil {
    var notFound *dakera.NotFoundError
    var rateLimit *dakera.RateLimitError
    switch {
    case errors.As(err, &notFound):
        fmt.Println("Not found")
    case errors.As(err, &rateLimit):
        fmt.Printf("Rate limited — retry after %ds\n", rateLimit.RetryAfter)
    default:
        fmt.Printf("Error: %v\n", err)
    }
}

Error types: *DakeraError, *ConnectionError, *NotFoundError, *ValidationError, *RateLimitError, *ServerError, *AuthenticationError, *AuthorizationError. All methods return (result, error).