Go SDK

go get github.com/PAIR-Systems-Inc/goodmem/clients/go@latest

import goodmem_client "github.com/PAIR-Systems-Inc/goodmem/clients/go"

package main

import (
    "context"
    "fmt"
    "log"

    goodmem_client "github.com/PAIR-Systems-Inc/goodmem/clients/go"
)

func main() {
    // Configure the API client
    configuration := goodmem_client.NewConfiguration()
    configuration.Host = "[http://localhost:8080"](http://localhost:8080")

    // Set authentication (replace with your API key)
    configuration.DefaultHeader["Authorization"] = "Bearer your-api-key-here"

    // Create API client
    apiClient := goodmem_client.NewAPIClient(configuration)

    // Create an API key
    apiKeysApi := apiClient.APIKeysAPI
    createRequest := *goodmem_client.NewCreateApiKeyRequest()

    // Add labels to the API key
    labels := map[string]string{
        "environment": "development",
        "service":     "chat-ui",
    }
    createRequest.SetLabels(labels)

    // Execute the API call
    ctx := context.Background()
    apiResponse, httpResponse, err := apiKeysApi.CreateApiKey(ctx).CreateApiKeyRequest(createRequest).Execute()
    if err != nil {
        log.Fatalf("Error creating API key: %v", err)
    }

    fmt.Printf("API Key created successfully!\n")
    fmt.Printf("API Key ID: %s\n", apiResponse.ApiKeyMetadata.GetApiKeyId())
    fmt.Printf("Raw API Key: %s\n", apiResponse.GetRawApiKey())
    fmt.Printf("HTTP Status: %d\n", httpResponse.StatusCode)
}

package main

import (
    "context"
    "fmt"
    "log"

    goodmem_client "github.com/PAIR-Systems-Inc/goodmem/clients/go"
)

func main() {
    // Configure client
    configuration := goodmem_client.NewConfiguration()
    configuration.Host = "[http://localhost:8080"](http://localhost:8080")
    configuration.DefaultHeader["Authorization"] = "Bearer your-api-key-here"

    apiClient := goodmem_client.NewAPIClient(configuration)

    // Create streaming client
    streamingClient := goodmem_client.NewStreamingClient(apiClient)

    // Get available spaces
    spacesApi := apiClient.SpacesAPI
    ctx := context.Background()
    
    spaces, _, err := spacesApi.ListSpaces(ctx).Execute()
    if err != nil {
        log.Fatalf("Error listing spaces: %v", err)
    }

    if len(spaces.GetSpaces()) == 0 {
        log.Fatal("No spaces available. Create a space first.")
    }

    spaceID := spaces.GetSpaces()[0].GetSpaceId()

    // Stream memory retrieval using simple method
    spaceIDs := []string{spaceID}
    stream, err := streamingClient.RetrieveMemoryStreamSimple(
        ctx,
        "your search query here",
        spaceIDs,
    )
    if err != nil {
        log.Fatalf("Error starting stream: %v", err)
    }
    defer stream.Close()

    // Process streaming events
    for {
        event, err := stream.Recv()
        if err != nil {
            if err.Error() == "EOF" {
                break // End of stream
            }
            log.Printf("Stream error: %v", err)
            break
        }

        // Handle different event types
        if event.AbstractReply != nil {
            fmt.Printf("📝 Abstract Reply: %s\n", event.AbstractReply.GetText())
            fmt.Printf("   Relevance Score: %.2f\n", event.AbstractReply.GetRelevanceScore())
        } else if event.RetrievedItem != nil && event.RetrievedItem.Memory != nil {
            memory := event.RetrievedItem.GetMemory()
            fmt.Printf("🧠 Retrieved Memory ID: %s\n", memory.GetMemoryId())
            
            // Access memory content if available
            if memory.Content != nil {
                fmt.Printf("   Content: %s\n", memory.Content.GetText())
            }
            
            // Access metadata
            if labels := memory.GetLabels(); len(labels) > 0 {
                fmt.Printf("   Labels: %v\n", labels)
            }
        } else if event.MemoryDefinition != nil {
            fmt.Printf("📋 Memory Definition received\n")
        }
    }
}

// Advanced streaming with custom post-processor configuration
advancedConfig := &goodmem_client.StreamingConfig{
    RequestedSize:        10,
    FetchMemory:         true,
    FetchMemoryContent:  false,
    Format:              "ndjson",
    PostProcessorName:   "com.goodmem.retrieval.postprocess.ChatPostProcessorFactory",
    PostProcessorConfig: map[string]interface{}{
        "llm_id":              "your-llm-uuid-here",
        "reranker_id":         "your-reranker-uuid-here",
        "relevance_threshold": 0.5,
        "max_results":         10,
        "chronological_resort": true,
    },
}

stream, err := streamingClient.RetrieveMemoryStreamAdvanced(
    ctx,
    "your search query",
    spaceIDs,
    advancedConfig,
)
// ... handle stream as above

configuration := goodmem_client.NewConfiguration()
configuration.Host = "[https://your-goodmem-server.com"](https://your-goodmem-server.com")

// For local development
configuration.Host = "[http://localhost:8080"](http://localhost:8080")

// Method 1: Using Authorization header
configuration.DefaultHeader["Authorization"] = "Bearer your-api-key"

// Method 2: Using API key authentication (if configured)
configuration.DefaultHeader["X-API-Key"] = "your-api-key"

import (
    "net/http"
    "time"
)

// Create custom HTTP client with timeout
httpClient := &http.Client{
    Timeout: 30 * time.Second,
}

configuration := goodmem_client.NewConfiguration()
configuration.HTTPClient = httpClient

apiResponse, httpResponse, err := apiClient.APIKeysAPI.CreateApiKey(ctx).Execute()
if err != nil {
    // Check if it's an API error with details
    if httpResponse != nil {
        fmt.Printf("HTTP Status: %d\n", httpResponse.StatusCode)
        fmt.Printf("Response: %v\n", httpResponse)
    }
    
    // Handle specific error types
    switch err.Error() {
    case "401":
        fmt.Println("Authentication failed - check your API key")
    case "404":
        fmt.Println("Resource not found")
    case "500":
        fmt.Println("Server error")
    default:
        fmt.Printf("API Error: %v\n", err)
    }
    return
}

## Run unit tests
go test ./...

## Run tests with verbose output
go test -v ./...

## Run streaming tests specifically
go test -v -run TestStreaming ./...