Go SDK

Installation

go get github.com/memoid/memoid-go

Quick Start

package main

import (
    "fmt"
    "github.com/memoid/memoid-go"
)

func main() {
    client := memoid.NewClient("your-api-key")

    // Add memory
    result, _ := client.Add(&memoid.AddRequest{
        Messages: []memoid.Message{
            {Role: "user", Content: "I love hiking"},
        },
        UserID: "user_123",
    })

    // Search
    results, _ := client.Search(&memoid.SearchRequest{
        Query:  "hobbies",
        UserID: "user_123",
    })

    for _, r := range results {
        fmt.Printf("%s (score: %.2f)\n", r.Memory, r.Score)
    }
}

Client Configuration

client := memoid.NewClient("your-api-key",
    memoid.WithBaseURL("https://api.memoid.dev"),
    memoid.WithTimeout(30 * time.Second),
)

Memory Operations

Add Memories

result, err := client.Add(&memoid.AddRequest{
    Messages: []memoid.Message{
        {Role: "user", Content: "My name is Alex"},
        {Role: "assistant", Content: "Nice to meet you!"},
    },
    UserID:       "user_123",
    AgentID:      "assistant_1",  // Optional
    Metadata:     map[string]any{"source": "chat"},
    Infer:        true,  // Extract facts
    ExtractGraph: false, // Extract entities
})

if err != nil {
    log.Fatal(err)
}

for _, m := range result.Memories {
    fmt.Printf("Added: %s\n", m.Memory)
}

List Memories

memories, err := client.List(&memoid.ListRequest{
    UserID: "user_123",
    Limit:  50,
})

for _, m := range memories {
    fmt.Printf("%s: %s\n", m.ID, m.Memory)
}

Get Memory

memory, err := client.Get("mem_abc123")
fmt.Println(memory.Memory)

Update Memory

err := client.Update("mem_abc123", &memoid.UpdateRequest{
    Memory:   "Updated text",
    Metadata: map[string]any{"updated": true},
})

Delete Memory

err := client.Delete("mem_abc123")

Delete All

err := client.DeleteAll(&memoid.DeleteAllRequest{
    UserID: "user_123",
})

Search

results, err := client.Search(&memoid.SearchRequest{
    Query:     "What does the user like?",
    UserID:    "user_123",
    Limit:     10,
    Threshold: 0.7,
})

for _, r := range results {
    fmt.Printf("%s (score: %.2f)\n", r.Memory, r.Score)
}

Knowledge Graph

Extract Knowledge

result, err := client.ExtractKnowledge(&memoid.ExtractRequest{
    Text:  "John works at Acme Corp",
    Store: true,
})

for _, e := range result.Entities {
    fmt.Printf("Entity: %s (%s)\n", e.Name, e.Type)
}

Add Entity

err := client.AddEntity(&memoid.Entity{
    Name: "Acme Corp",
    Type: "organization",
    Attributes: map[string]any{"industry": "tech"},
})

Add Relationship

err := client.AddRelationship(&memoid.Relationship{
    Source:   "John",
    Relation: "works_at",
    Target:   "Acme Corp",
})

Query Graph

result, err := client.GraphQuery(&memoid.GraphQueryRequest{
    Entity: "John",
    Depth:  2,
})

for _, e := range result.Entities {
    fmt.Println(e.Name)
}

Error Handling

result, err := client.Add(&memoid.AddRequest{...})
if err != nil {
    switch e := err.(type) {
    case *memoid.RateLimitError:
        fmt.Printf("Rate limited. Retry after %d seconds\n", e.RetryAfter)
    case *memoid.APIError:
        fmt.Printf("API error: %s\n", e.Message)
    default:
        fmt.Printf("Error: %v\n", err)
    }
}

Complete Example

package main

import (
    "context"
    "fmt"
    "strings"

    "github.com/memoid/memoid-go"
    "github.com/sashabaranov/go-openai"
)

func main() {
    memory := memoid.NewClient("memoid-key")
    ai := openai.NewClient("openai-key")

    reply := chat(memory, ai, "user_123", "What are my hobbies?")
    fmt.Println(reply)
}

func chat(memory *memoid.Client, ai *openai.Client, userID, message string) string {
    // Get context
    results, _ := memory.Search(&memoid.SearchRequest{
        Query:  message,
        UserID: userID,
        Limit:  5,
    })

    var contextLines []string
    for _, r := range results {
        contextLines = append(contextLines, "- "+r.Memory)
    }
    context := strings.Join(contextLines, "\n")

    // Generate response
    resp, _ := ai.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: openai.GPT4,
            Messages: []openai.ChatCompletionMessage{
                {Role: "system", Content: "Context:\n" + context},
                {Role: "user", Content: message},
            },
        },
    )

    reply := resp.Choices[0].Message.Content

    // Store conversation
    memory.Add(&memoid.AddRequest{
        Messages: []memoid.Message{
            {Role: "user", Content: message},
            {Role: "assistant", Content: reply},
        },
        UserID: userID,
    })

    return reply
}