[Question]: How to use MilvusVectorStore with text_key and additional metadata? about llama_index HOT 3 OPEN

def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
    """Query index for top k most similar nodes.

    Args:
        query_embedding (List[float]): query embedding
        similarity_top_k (int): top k most similar nodes
        doc_ids (Optional[List[str]]): list of doc_ids to filter by
        node_ids (Optional[List[str]]): list of node_ids to filter by
        output_fields (Optional[List[str]]): list of fields to return
        embedding_field (Optional[str]): name of embedding field
    """
    if query.mode != VectorStoreQueryMode.DEFAULT:
        raise ValueError(f"Milvus does not support {query.mode} yet.")

    expr = []
    output_fields = ["*"]

    # Parse the filter
    if query.filters is not None:
        expr.extend(_to_milvus_filter(query.filters))

    # Parse any docs we are filtering on
    if query.doc_ids is not None and len(query.doc_ids) != 0:
        expr_list = ['"' + entry + '"' for entry in query.doc_ids]
        expr.append(f"{self.doc_id_field} in [{','.join(expr_list)}]")

    # Parse any nodes we are filtering on
    if query.node_ids is not None and len(query.node_ids) != 0:
        expr_list = ['"' + entry + '"' for entry in query.node_ids]
        expr.append(f"{MILVUS_ID_FIELD} in [{','.join(expr_list)}]")

    # Limit output fields
    if query.output_fields is not None:
        output_fields = query.output_fields

    # Convert to string expression
    string_expr = ""
    if len(expr) != 0:
        string_expr = " and ".join(expr)

    # Perform the search
    res = self.milvusclient.search(
        collection_name=self.collection_name,
        data=[query.query_embedding],
        filter=string_expr,
        limit=query.similarity_top_k,
        output_fields=output_fields,
        search_params=self.search_config,
    )

    logger.debug(
        f"Successfully searched embedding in collection: {self.collection_name}"
        f" Num Results: {len(res[0])}"
    )

    nodes = []
    similarities = []
    ids = []

    # Parse the results
    for hit in res[0]:
        if not self.text_key:
            node = metadata_dict_to_node(
                {
                    "_node_content": hit["entity"].get("_node_content", None),
                    "_node_type": hit["entity"].get("_node_type", None),
                }
            )
        else:
            try:
                text = hit["entity"].get(self.text_key)
            except Exception:
                raise ValueError(
                    "The passed in text_key value does not exist "
                    "in the retrieved entity."
                )

            metadata = {
                key: hit["entity"].get(key) for key in output_fields if key != self.text_key
            }
            node = TextNode(text=text, metadata=metadata)

        nodes.append(node)
        similarities.append(hit["distance"])
        ids.append(hit["id"])

    return VectorStoreQueryResult(nodes=nodes, similarities=similarities, ids=ids)

from llama_index.vector_stores.milvus import MilvusVectorStore

# Setup MilvusVectorStore
vector_store = MilvusVectorStore(
    dim=1536,
    collection_name="your_collection_name",
    uri="http://milvus_address:port",
    token="your_milvus_token_here",
    overwrite=True,
    text_key="your_text_key",  # Specify the key where the text is stored
    output_fields=["metadata_field1", "metadata_field2"]  # Specify only the metadata fields you want
)

def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
    ...
    output_fields = ["*"]

    # Limit output fields
    if query.output_fields is not None:
        output_fields = query.output_fields
    elif len(self.output_fields) > 0:
        output_fields = self.output_fields
    ...