Ir a Milvus rápidamente

Este capítulo introduce cómo empezar rápidamente con las operaciones de lectura y escritura de la base de datos de vectores Milvus utilizando Go.

Instalación del SDK de Go

Nota: El SDK de Go requiere la versión 1.15 o superior de Go.

go get -u github.com/milvus-io/milvus-sdk-go/v2

Importación de Dependencias

import (
	"context"
	"fmt"
	"log"
	"math/rand"
	"time"

	"github.com/milvus-io/milvus-sdk-go/v2/client"
	"github.com/milvus-io/milvus-sdk-go/v2/entity"
)

Conexión a la Base de Datos de Milvus

	ctx := context.Background()

	log.Printf(msgFmt, "Conectando a Milvus")
	c, err := client.NewClient(ctx, client.Config{
		Address: "localhost:19530",
	})
	if err != nil {
		log.Fatal("No se pudo conectar a Milvus, err: ", err.Error())
	}
	defer c.Close()

Creación de una Colección

El proceso de creación de una colección es similar a la creación de la estructura de una tabla en MySQL, en donde es necesario describir el tipo de cada campo.

	collectionName = "hello_tizi365"
	log.Printf(msgFmt, fmt.Sprintf("Creando colección, `%s`", collectionName))
	
	// Define los tipos de campo de la colección, definiendo ID, random y embeddings aquí
	esquema := entity.NewSchema().WithName(collectionName).WithDescription("Descripción de la colección").
		WithField(entity.NewField().WithName("ID").WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(false)).
		WithField(entity.NewField().WithName("random").WithDataType(entity.FieldTypeDouble)).
		WithField(entity.NewField().WithName("embeddings").WithDataType(entity.FieldTypeFloatVector).WithDim(dim))

	// Crea la colección basada en los tipos de campo de colección definidos
	if err := c.CreateCollection(ctx, esquema, entity.DefaultShardNumber); err != nil {
		log.Fatalf("Error al crear la colección, err: %v", err)
	}

Ingresando Datos en la Colección

	idList, randomList := make([]int64, 0, nEntities), make([]float64, 0, nEntities)
	embeddingList := make([][]float32, 0, nEntities)

	rand.Seed(time.Now().UnixNano())

    // Para propósitos de prueba, generamos algunos datos de prueba aleatorios aquí
	// Generar IDs
	for i := 0; i < nEntities; i++ {
		idList = append(idList, int64(i))
	}
	// Generar valores aleatorios
	for i := 0; i < nEntities; i++ {
		randomList = append(randomList, rand.Float64())
	}
	// Generar valores de vector
	for i := 0; i < nEntities; i++ {
		vec := make([]float32, 0, dim)
		for j := 0; j < dim; j++ {
			vec = append(vec, rand.Float32())
		}
		embeddingList = append(embeddingList, vec)
	}
	// Insertar múltiples conjuntos de datos, organizados por columna para múltiples datos
	idColData := entity.NewColumnInt64("ID", idList)
	randomColData := entity.NewColumnDouble("random", randomList)
	embeddingColData := entity.NewColumnFloatVector("embeddings", dim, embeddingList)

    // Insertar datos
	if _, err := c.Insert(ctx, collectionName, "", idColData, randomColData, embeddingColData); err != nil {
		log.Fatalf("Error al escribir los datos, err: %v", err)
	}
    
	// Guardar los datos en disco
	if err := c.Flush(ctx, collectionName, false); err != nil {
		log.Fatalf("Error al guardar los datos, err: %v", err)
	}

Creación de Índice

	// Define el tipo de índice
	idx, err := entity.NewIndexIvfFlat(entity.L2, 128)
	if err != nil {
		log.Fatalf("Error al definir el índice, err: %v", err)
	}
	// Crea un índice para la colección especificada
	if err := c.CreateIndex(ctx, collectionName, embeddingCol, idx, false); err != nil {
		log.Fatalf("Error al crear el índice, err: %v", err)
	}

    // Carga la colección especificada en memoria para mejorar la eficiencia de la consulta
	err = c.LoadCollection(ctx, collectionName, false)
	if err != nil {
		log.Fatalf("Error al cargar la colección, err: %v", err)
	}

Búsqueda de similitud de vectores

   // Preparar los vectores a buscar. Aquí extraemos parte de los datos del vector de los datos generados previamente para pruebas, y buscaremos resultados similares a estos vectores a continuación.
	vec2search := []entidad.Vector{
		entidad.VectorFlotante(listaIncrustaciones[len(listaIncrustaciones)-2]),
		entidad.VectorFlotante(listaIncrustaciones[len(listaIncrustaciones)-1]),
	}
	comienzo := time.Now()
	sp, _ := entidad.NuevoParametroBusquedaIndexIvfFlat(16)
	// Realizar búsqueda de similitud de vectores
	resultados, err := cliente.Buscar(ctx, nombreColeccion, nil, "", []string{"aleatorio"}, vec2search,
		"incrustaciones", entidad.L2, topK, sp)
	fin := time.Now()
	if err != nil {
		log.Fatalf("Búsqueda fallida, err: %v", err)
	}

	log.Println("Imprimir resultados:")
	for _, res := range resultados {
		imprimirResultado(&res)
	}

Definición de la función imprimirResultado

func imprimirResultado(resultado *cliente.ResultadoBusqueda) {
	aleatorios := make([]float64, 0, resultado.CantidadResultados)
	puntajes := make([]float32, 0, resultado.CantidadResultados)

	var columnaAleatoria *entidad.ColumnaDouble
	for _, campo := range resultado.Campos {
		if campo.Nombre() == columnaAleatoria {
			c, ok := campo.(*entidad.ColumnaDouble)
			if ok {
				columnaAleatoria = c
			}
		}
	}
	for i := 0; i < resultado.CantidadResultados; i++ {
		valor, err := columnaAleatoria.ValorPorIndice(i)
		if err != nil {
			log.Fatal(err)
		}
		aleatorios = append(aleatorios, valor)
		puntajes = append(puntajes, resultado.Puntajes[i])
	}
	log.Printf("\taleatorios: %v, puntajes: %v\n", aleatorios, puntajes)
}

Código fuente de demostración completa, Código fuente de inicio de Go Milvus