Chroma Go

For optimal search performance, combine dense and sparse vectors:

• Hybrid Search: Use both dense vectors (for semantic meaning) and sparse vectors (for exact keyword matching) to achieve the best results.
• Reciprocal Rank Fusion (RRF): Use RRF to combine the results from dense and sparse searches.
• Weight Tuning: When combining results, start with a weight ratio of 0.7 (dense) / 0.3 (sparse) and adjust based on your specific use case.
• Result Iteration: Use the Rows() method for ergonomic iteration over search results, and At(group, index) for safe indexed access with bounds checking.

Beyond basic indexing, the schema API supports fine-tuning for specific workloads:

• HNSW Tuning: Use WithHnsw() for fine-grained control over the HNSW graph.
• Cloud-Scale Workloads: Use WithSpann() to configure SPANN (Scalable Partitioned Approximate Nearest Neighbors) for large-scale datasets in Chroma Cloud.
• Persistence: Schemas are automatically persisted along with the collection.

To implement zero-indexed pagination (where Page 0 is the first set of results), use the following formula for the offset:

offset = page_number * page_size

Example pattern for Page $N$:

• Page 0: Limit(pageSize), Offset(0)
• Page 1: Limit(pageSize), Offset(pageSize)
• Page 2: Limit(pageSize), Offset(2 * pageSize)

// General formula for page N
getPage := func(pageNumber int, pageSize int) v2.SearchCollectionOption {
	return v2.NewSearchRequest(
		v2.NewPage(
			v2.Limit(pageSize),
			v2.Offset(pageNumber*pageSize),
		),
	)
}

// Get page 5
page5, _ := collection.Search(ctx, getPage(5, 10))

Complex queries can be constructed by nesting logical operators. All filter types (equality, comparison, inclusion, etc.) can be combined using:

• v2.And(...): Requires all provided conditions to be met.
• v2.Or(...): Requires at least one of the provided conditions to be met.

The Chroma Go client supports reranking to improve search relevance. Supported rerankers include:

• Cohere
• Jina AI
• HuggingFace Embedding Inference Server (HFEI)
• Together AI

When working with collections in chroma-go, keep the following operational constraints and best practices in mind:

• Uniqueness: Collection names must be unique within a single database.
• Persistence: The embedding function is persisted along with the collection (requires Chroma version >= 1.1.13).
• Error Prevention: Use GetOrCreateCollection instead of CreateCollection if you want to avoid errors when a collection might already exist.
• Data Safety: Deleting a collection is a permanent operation and removes all associated data.
• Resource Management: Always use defer client.Close() to ensure client resources are properly released after use.

When using the get or query methods, you can filter the returned records based on their metadata by providing a where argument. To ensure clarity and avoid ambiguity in filter expressions, use v2.K("field_name") to explicitly mark metadata field names.

This allows you to target specific keys within the metadata dictionary of your stored documents.

// Example concept of using the where argument
// (Note: Full implementation details follow in subsequent segments)
// client.Query(ctx, collectionName, queryText, &chroma.QueryOptions{
//     Where: v2.K("my_metadata_field").Eq("some_value"),
// })

Collection forking allows you to create isolated copies of existing collections to support several workflows:

• Data versioning/checkpointing: Maintain consistent snapshots as your data evolves.
• Git-like workflows: Index a branch by forking from its divergence point, then apply the diff.
• A/B testing: Compare different embedding strategies or data configurations.
• Safe experimentation: Test changes without affecting production data.