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",
    Query:     "revenue trends",
    TopK:      5,
})

Namespace management

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

// 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,
})

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).