from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.load()
 

await milvusClient.loadCollection({
  collection_name: "book",
});
 

err := milvusClient.LoadCollection(
  context.Background(),   // ctx
  "book",                 // CollectionName
  false                   // async
)
if err != nil {
  log.Fatal("failed to load collection:", err.Error())
}
 

milvusClient.loadCollection(
  LoadCollectionParam.newBuilder()
          .withCollectionName("book")
          .build()
);
 

load -c book
 

curl -X 'POST' 
  'http://localhost:9091/api/v1/collection/load' 
  -H 'accept: application/json' 
  -H 'Content-Type: application/json' 
  -d '{
    "collection_name": "book"
  }'
 

search_params = {"metric_type": "L2", "params": {"nprobe": 10}, "offset": 5}
 

const searchParams = {
  anns_field: "book_intro",
  topk: "2",
  metric_type: "L2",
  params: JSON.stringify({ nprobe: 10 }),
};
 

sp, _ := entity.NewIndexFlatSearchParam( // NewIndex*SearchParam func
	10,                                  // searchParam
)
 

final Integer SEARCH_K = 2;                       // TopK
final String SEARCH_PARAM = "{"nprobe":10, ”offset”:5}";    // Params
 

search
 
Collection name (book): book
 
The vectors of search data(the length of data is number of query (nq), the dim of every vector in data must be equal to vector field’s of collection. You can also import a csv file without headers): [[0.1, 0.2]]
 
The vector field used to search of collection (book_intro): book_intro
 
Metric type: L2
 
Search parameter nprobe's value: 10
 
The max number of returned record, also known as topk: 10
 
The boolean expression used to filter attribute []: 
 
The names of partitions to search (split by "," if multiple) ['_default'] []: 
 
timeout []:
 
Guarantee Timestamp(It instructs Milvus to see all operations performed before a provided timestamp. If no such timestamp is provided, then Milvus will search all operations performed to date) [0]: 
 
Travel Timestamp(Specify a timestamp in a search to get results based on a data view) [0]:
 

curl -X 'POST' 
  'http://localhost:9091/api/v1/search' 
  -H 'accept: application/json' 
  -H 'Content-Type: application/json' 
  -d '{
    "collection_name": "book",
    "output_fields": ["book_id"],
    "search_params": [
      {"key": "anns_field", "value": "book_intro"},
      {"key": "topk", "value": "2"},
      {"key": "params", "value": "{"nprobe": 10}"},
      {"key": "metric_type", "value": "L2"},
      {"key": "round_decimal", "value": "-1"}
    ],
    "vectors": [ [0.1,0.2] ],
    "dsl_type": 1
  }'
 

{
  "status":{},
  "results":{
    "num_queries":1,
    "top_k":2,
    "fields_data":[
      {
        "type":5,
        "field_name":"book_id",
        "Field":{"Scalars":{"Data":{"LongData":{"data":[1,2]}}}},
        "field_id":100
      }
    ],
    "scores":[1.45,4.25],
    "ids":{"IdField":{"IntId":{"data":[1,2]}}},
    "topks":[2]},
    "collection_name":"book"
}
 

results = collection.search(
	data=[[0.1, 0.2]], 
	anns_field="book_intro", 
	param=search_params,
	limit=10, 
	expr=None,
	output_fields=['title'] # set the names of the fields you want to retrieve from the search result.
	consistency_level="Strong"
)
 
# get the IDs of all returned hits
results[0].ids
 
# get the distances to the query vector from all returned hits
results[0].distances
 
# get the value of an output field specified in the search request.
# vector fields are not supported yet.
hit = results[0][0]
hit.entity.get('title')
 

const results = await milvusClient.search({
  collection_name: "book",
  expr: "",
  vectors: [[0.1, 0.2]],
  search_params: searchParams,
  vector_type: 101,    // DataType.FloatVector
});
 

searchResult, err := milvusClient.Search(
	context.Background(),                    // ctx
	"book",                                  // CollectionName
	[]string{},                              // partitionNames
	"",                                      // expr
	[]string{"book_id"},                     // outputFields
	[]entity.Vector{entity.FloatVector([]float32{0.1, 0.2})}, // vectors
	"book_intro",                            // vectorField
	entity.L2,                               // metricType
	2,                                       // topK
	sp,                                      // sp
)
if err != nil {
	log.Fatal("fail to search collection:", err.Error())
}
 

List<String> search_output_fields = Arrays.asList("book_id");
List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(0.1f, 0.2f));
 
SearchParam searchParam = SearchParam.newBuilder()
		.withCollectionName("book")
		.withConsistencyLevel(ConsistencyLevelEnum.STRONG)
		.withMetricType(MetricType.L2)
		.withOutFields(search_output_fields)
		.withTopK(SEARCH_K)
		.withVectors(search_vectors)
		.withVectorFieldName("book_intro")
		.withParams(SEARCH_PARAM)
		.build();
R<SearchResults> respSearch = milvusClient.search(searchParam);
 

# Follow the previous step.
 

# Follow the previous step.
 

results[0].ids
results[0].distances
 

console.log(results.results)
 

fmt.Printf("%#v", searchResult)
for _, sr := range searchResult {
	fmt.Println(sr.IDs)
	fmt.Println(sr.Scores)
}
 

SearchResultsWrapper wrapperSearch = new SearchResultsWrapper(respSearch.getData().getResults());
System.out.println(wrapperSearch.getIDScore(0));
System.out.println(wrapperSearch.getFieldData("book_id", 0));
 

# Milvus CLI automatically returns the primary key values of the most similar vectors and their distances.
 

collection.release()
 

await milvusClient.releaseCollection({  collection_name: "book",});
 

err := milvusClient.ReleaseCollection(
    context.Background(),                            // ctx
    "book",                                          // CollectionName
)
if err != nil {
    log.Fatal("failed to release collection:", err.Error())
}
 

milvusClient.releaseCollection(
		ReleaseCollectionParam.newBuilder()
                .withCollectionName("book")
                .build());
 

release -c book
 

curl -X 'DELETE' 
  'http://localhost:9091/api/v1/collection/load' 
  -H 'accept: application/json' 
  -H 'Content-Type: application/json' 
  -d '{
    "collection_name": "book"
  }'