Retrieval and Streaming

Get exports every entry stored under one key, converted to the scalar kind you name, in one call however many there turn out to be:

vectors, _ := index.Get(usearch.KeyFromUint64(42), usearch.ScalarF32, arena)
// vectors.Rows() rows of vectors.Columns(), vectors.Stride() bytes apart
values, _ := usearch.DenseValues[float32](vectors)

A cursor walks the contents, each pull writing up to wanted keys, and the keys each links to for NextLinks, into an arena; the vectors themselves come from Get. NextKeys pulls the keys alone, and a batch of none means the walk is exhausted. Cursor() yields every entry as stored, and Cursor(starts...) the starts’ own entries first, then the entries those link to breadth-first, each once. Cursors answer on RAM and NVMe handles, while VRAM entries are read back by key or by search.

cursor, _ := index.On(executor).Cursor()
defer cursor.Close()
for {
	batch, err := cursor.NextLinks(1024, arena)
	if err != nil || batch.Written() == 0 {
		break
	}
	keys, _ := batch.Keys()
	first, _ := batch.Links(0)
	consume(keys, first)
}

A search stream resumes one query’s walk, so a caller that post-filters aggressively pulls until satisfied instead of guessing the wanted count upfront. Each Next writes up to wanted next-nearest matches into an arena as the one query of a search, and a query with none means the walk is drained. Ordering beyond the expansion horizon is best-effort nearest rather than globally exact. No residency streams matches yet, so SearchStream answers StatusUnsupported today.

stream, err := index.On(executor).SearchStream(usearch.RowsOf(query, dimensions), nil)
	if err != nil {
		log.Fatal(err)
}
defer stream.Close()
for accepted := 0; accepted < 10; {
	matches, err := stream.Next(64, arena)
	if err != nil {
		log.Fatal(err)
}
	found, _, _ := matches.Query(0)
	if len(found) == 0 {
		break // the walk is drained
}
	for _, key := range found {
		if admits(key) {
			accepted++
}
}
}

§ Sampling

Sample draws keys around Focus, or across the whole index, each hanging from a shown or earlier draw and placed in three dimensions beside the Shown keys already on screen, so a view grows one connected sample as it zooms. Equal seeds, shown keys and focus draw equally, and a larger wanted draws a superset.

draws, err := index.On(executor).Sample(256, arena, &usearch.DenseSampleConfig{
	Shown: shown, ShownCoordinates: places, Focus: near, Seed: 42,
})
keys, _ := draws.Keys()
entryOrdinals, _ := draws.EntryOrdinals()
parent, distance, _ := draws.Parents().Query(0) // empty for a root
points, _ := usearch.DenseValues[float32](draws.Coordinates())