gracedb

package main

import (
    "fmt"
    "log"

    "github.com/dshmyz/gracedb/pkg/gracedb"
)

func main() {
    // Open database
    db, err := gracedb.Open("/tmp/gracedb-data")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Create collection
    coll, _ := db.CreateCollection("my_docs")
    fmt.Println("created:", coll.Name)

    // Insert vector
    vec := []float32{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8}
    embID, _ := db.Upsert("my_docs", "doc-1", vec, "Hello world", nil, nil)
    fmt.Println("embedded:", embID)

    // Search
    results, _ := db.Search("my_docs", vec, gracedb.SearchOptions{
        TopK:            5,
        UseVectorSearch: true,
    })
    fmt.Println("found:", len(results), "results")

    // Backup
    db.Backup("/tmp/gracedb-backup.db")

    // Quick API
    q := db.Quick()
    id, _ := q.AddToCollection(ctx, "my_docs", vec, "Quick add")
    fmt.Println("quick add:", id)
}

db, _ := gracedb.Open("/tmp/data",
    gracedb.WithIndexType("hnsw"),         // hnsw / ivf / flat / lsh
    gracedb.WithIndexTypes([]string{"hnsw", "lsh"}), // multi-index hybrid
    gracedb.WithSimilarity("cosine"),       // cosine / euclidean
    gracedb.WithEmbedder(myEmbedder),       // types.Embedder interface
)

db, _ := gracedb.Open("/tmp/data", gracedb.WithEmbedder(myEmbedder))

// Insert text (auto-vectorized)
id, _ := db.InsertText("docs", "text-1", "This is Chinese text", nil)

// Text search (vectorized or FTS fallback)
results, _ := db.SearchText("docs", "Chinese", 10)

// Save knowledge (auto-chunked)
record, _ := db.SaveKnowledge("docs", "wiki-1", "Go Language",
    "Go is a statically typed, compiled language...",
    types.KnowledgeSaveRequest{ChunkSize: 500, ChunkOverlap: 50})

// Search knowledge
resp, _ := db.SearchKnowledge("docs", "programming language", 5)

// Save memory with scope/namespace
db.SaveMemory(types.MemorySaveRequest{
    MemoryID:  "mem-1",
    Content:   "User prefers Go over Python",
    Scope:     "user",
    UserID:    "user-123",
    Namespace: "preferences",
    TTLSeconds: 3600,
})

// Search memory
resp, _ := db.SearchMemory(types.MemorySearchRequest{
    Query:  "prefers",
    UserID: "user-123",
    Scope:  "user",
    TopK:   5,
})

g := db.Graph()

g.UpsertNode(&graph.GraphNode{
    ID: "person-1", Type: "person",
    Properties: map[string]string{"name": "Alice"},
})
g.UpsertNode(&graph.GraphNode{
    ID: "lang-1", Type: "language",
    Properties: map[string]string{"name": "Go"},
})
g.UpsertEdge(&graph.GraphEdge{
    FromNodeID: "person-1", ToNodeID: "lang-1",
    Type: "likes", Weight: 1.0,
})

// Query neighbors
nodes, edges, _ := g.GetNeighbors("person-1", graph.NeighborOptions{
    Direction: "out", Limit: 10,
})

// Traversal
result, _ := g.BFS("person-1", graph.NeighborOptions{MaxDepth: 2})

rdf := db.RDF()

// Insert triple
rdf.UpsertTriple(&rdf.Triple{
    Subject:   rdf.NewIRI("http://example.org/person/1"),
    Predicate: rdf.NewIRI("http://example.org/likes"),
    Object:    rdf.NewIRI("http://example.org/lang/go"),
})

// SPARQL query
results, _ := rdf.SPARQLSelect(`SELECT ?s ?p ?o WHERE { ?s ?p ?o . }`)

// Solution modifiers: FILTER, ORDER BY, LIMIT
top, _ := rdf.SPARQLSelect(
    `SELECT ?person ?name WHERE { ?person <http://schema.org/name> ?name FILTER(?name >= "A") } ORDER BY DESC(?name) LIMIT 3`)

// ASK query
exists, _ := rdf.SPARQLAsk(`ASK WHERE { <http://example.org/person/1> ?p ?o . }`)

// GROUP BY aggregation: count items per type, keep groups with count > 1
counts, _ := rdf.SPARQLSelect(`
    SELECT ?type (COUNT(?item) AS ?c) WHERE {
      ?item <http://ex.com/type> ?type
    } GROUP BY ?type HAVING (COUNT(?item) > 1)`)

o := db.Ontology()

// Define ontology
o.DefineClass("http://example.org/Person", "")
o.DefineClass("http://example.org/Developer", "http://example.org/Person")
o.DefineProperty("http://example.org/knows", "http://example.org/Person", "http://example.org/Person")

// Add facts
o.AddFact("http://example.org/person/alice", "http://example.org/knows", "Bob")

// RDFS inference (materialize new triples)
count, _ := o.Infer()

// SHACL validation
report, _ := o.Validate()

km := db.KnowledgeMemory(nil) // nil = use rule-based reflector

// Recall: fused memory + knowledge + graph expansion
resp, _ := km.Recall(ctx, knowledge.KnowledgeMemoryRecallRequest{
    Query:         "what does the user like?",
    TopKMemories:  5,
    TopKKnowledge: 4,
    MaxHops:       2, // graph expansion depth
})

// Reflect: synthesize structured summary
reflection, _ := km.Reflect(ctx, knowledge.KnowledgeMemoryReflectRequest{
    Query: "user preferences",
})
fmt.Println("Summary:", reflection.Summary)
fmt.Println("Themes:", reflection.Themes)

// Consolidate: store summary + optionally promote to knowledge
consolidated, _ := km.Consolidate(ctx, knowledge.KnowledgeMemoryConsolidateRequest{
    Reflect: knowledge.KnowledgeMemoryReflectRequest{
        Query: "user preferences",
    },
    PromoteToKnowledge: true,
})

db.SetFactExtractor(func(ctx context.Context, msgs []*types.Message) ([]gracedb.ExtractedFact, error) {
    // Extract facts from conversation (can use LLM here)
    return []gracedb.ExtractedFact{
        {ID: "fact-1", Content: "User likes Go", Type: "preference"},
    }, nil
})

db.SetAutoRetain(gracedb.AutoRetainConfig{
    Enabled:      true,
    WindowSize:   6,
    TriggerEvery: 2, // extract every 2 messages
})

// AddMessage now triggers extraction automatically
db.AddMessage(&types.Message{SessionID: "sess-1", Role: "user", Content: "I like Go"})
db.AddMessage(&types.Message{SessionID: "sess-1", Role: "assistant", Content: "Go is great!"})
// → AutoRetain fires, extracts facts, stores as memory

// Simple aggregation
result, _ := db.Aggregate("docs", "score", store.AggAvg)
fmt.Printf("Average score: %.2f\n", result.Avg)

// GROUP BY aggregation
groups, _ := db.GroupAggregate("docs", "category", "price", store.AggAvg)
for category, r := range groups {
    fmt.Printf("%s: avg=%.2f, count=%d\n", category, r.Avg, r.Count)
}

server := db.MCPServer()
server.RunStdio(context.Background())

db.Backup("/tmp/backup.db")

db2, _ := gracedb.Open("/tmp/restored")
db2.Restore("/tmp/backup.db")

// Preload index (from snapshot or rebuild) — optional
db.LoadIndex("docs")

// Save index snapshot
db.SaveIndex("docs")

// Rebuild FTS index
db.RebuildIndex("docs")