vector

ExampleNewFallbackEmbedder shows filtering out non-text blocks before delegating to the primary embedder, and counting skipped blocks.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/Germanblandin1/goagent"
	"github.com/Germanblandin1/goagent/internal/testutil"
	"github.com/Germanblandin1/goagent/memory/vector"
)

func main() {
	skipped := 0
	emb := vector.NewFallbackEmbedder(
		&testutil.MockEmbedder{},
		vector.WithSupportedType(goagent.ContentText),
		vector.WithOnSkipped(func(_ goagent.ContentBlock) { skipped++ }),
	)

	blocks := []goagent.ContentBlock{
		goagent.TextBlock("embeddable text"),
		goagent.ImageBlock([]byte{0xFF}, "image/png"), // skipped — not ContentText
	}
	vec, err := emb.Embed(context.Background(), blocks)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(len(vec) > 0)
	fmt.Println(skipped)
}

Output:
true
1

ExampleNewInMemoryStore shows upserting a vector, counting entries, and searching for the nearest neighbour.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/Germanblandin1/goagent"
	"github.com/Germanblandin1/goagent/memory/vector"
)

func main() {
	ctx := context.Background()
	store := vector.NewInMemoryStore()

	msg := goagent.AssistantMessage("vector databases store embeddings")
	vec := []float32{1, 0, 0} // unit-length vector

	if err := store.Upsert(ctx, "doc:0", vec, msg); err != nil {
		log.Fatal(err)
	}

	count, _ := store.Count(ctx)
	fmt.Println(count)

	results, err := store.Search(ctx, []float32{1, 0, 0}, 1)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(results[0].Message.TextContent())
}

Output:
1
vector databases store embeddings

ExampleNewNoOpChunker shows a chunker that returns its input as a single unchanged chunk — useful when the content already fits within model limits.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/Germanblandin1/goagent"
	"github.com/Germanblandin1/goagent/memory/vector"
)

func main() {
	ctx := context.Background()
	chunker := vector.NewNoOpChunker()

	content := vector.ChunkContent{
		Blocks:   []goagent.ContentBlock{goagent.TextBlock("original text")},
		Metadata: map[string]any{"source": "doc.md"},
	}
	chunks, err := chunker.Chunk(ctx, content)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(len(chunks))
	fmt.Println(vector.ExtractText(chunks[0].Blocks))
}

Output:
1
original text

ExampleNewOllamaTokenEstimator shows constructing an estimator that calls the Ollama tokenize API for exact token counts. No Output: because it makes HTTP requests to a local Ollama server.

package main

import (
	"github.com/Germanblandin1/goagent/memory/vector"
)

func main() {
	est := vector.NewOllamaTokenEstimator("llama3.2")
	_ = est
}

Output:

ExampleNewRecursiveChunker shows splitting a two-paragraph document at the paragraph boundary (\n\n) before falling back to finer separators.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/Germanblandin1/goagent"
	"github.com/Germanblandin1/goagent/memory/vector"
)

func main() {
	ctx := context.Background()
	chunker := vector.NewRecursiveChunker(
		vector.WithRCMaxSize(30),
		vector.WithRCOverlap(0),
		vector.WithRCEstimator(&vector.CharEstimator{}),
	)

	content := vector.ChunkContent{
		Blocks: []goagent.ContentBlock{
			goagent.TextBlock("First paragraph text here.\n\nSecond paragraph text here."),
		},
	}
	chunks, err := chunker.Chunk(ctx, content)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(len(chunks))
	fmt.Println(vector.ExtractText(chunks[0].Blocks))
	fmt.Println(vector.ExtractText(chunks[1].Blocks))
}

Output:
2
First paragraph text here.
Second paragraph text here.

ExampleNewSentenceChunker shows grouping sentences into chunks that respect MaxSize, with one overlapping sentence between adjacent chunks for context.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/Germanblandin1/goagent"
	"github.com/Germanblandin1/goagent/memory/vector"
)

func main() {
	ctx := context.Background()
	chunker := vector.NewSentenceChunker(
		vector.WithSentenceMaxSize(20),
		vector.WithSentenceOverlap(0),
		vector.WithSentenceEstimator(&vector.CharEstimator{}),
	)

	content := vector.ChunkContent{
		Blocks: []goagent.ContentBlock{
			goagent.TextBlock("Go is fast. It uses goroutines."),
		},
	}
	chunks, err := chunker.Chunk(ctx, content)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(len(chunks))
	fmt.Println(vector.ExtractText(chunks[0].Blocks))
	fmt.Println(vector.ExtractText(chunks[1].Blocks))
}

Output:
2
Go is fast.
It uses goroutines.

ExampleNewTextChunker shows splitting text at word boundaries when it exceeds MaxSize, with zero overlap between adjacent chunks.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/Germanblandin1/goagent"
	"github.com/Germanblandin1/goagent/memory/vector"
)

func main() {
	ctx := context.Background()
	chunker := vector.NewTextChunker(
		vector.WithMaxSize(10),
		vector.WithOverlap(0),
		vector.WithEstimator(&vector.CharEstimator{}),
	)

	content := vector.ChunkContent{
		Blocks: []goagent.ContentBlock{goagent.TextBlock("hello world foo bar")},
	}
	chunks, err := chunker.Chunk(ctx, content)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(len(chunks))
	fmt.Println(vector.ExtractText(chunks[0].Blocks))
	fmt.Println(vector.ExtractText(chunks[1].Blocks))
}

Output:
2
hello world
foo bar