> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/avnlp/vectordb/llms.txt > Use this file to discover all available pages before exploring further. # Database wrappers > Core vector database wrapper APIs for Chroma, Milvus, Pinecone, Qdrant, and Weaviate Core database wrapper classes that provide unified interfaces to vector databases. These wrappers are used by both Haystack and LangChain integrations. ## ChromaVectorDB Comprehensive Chroma Vector Database interface for Haystack integration with support for cloud deployments, local persistent storage, and ephemeral in-memory storage. ### Constructor ```python theme={null} ChromaVectorDB( host: Optional[str] = None, port: Optional[int] = None, api_key: Optional[str] = None, tenant: Optional[str] = None, database: Optional[str] = None, path: Optional[str] = None, persistent: bool = True, collection_name: Optional[str] = None, config: Optional[Dict[str, Any]] = None, config_path: Optional[str] = None, **kwargs: Any ) ``` Chroma server hostname for HttpClient connections Chroma server port number (default: 8000) API key for authenticated Chroma instances Tenant name for multi-tenant mode (default: "default\_tenant") Database name within tenant (default: "default\_database") Local storage path for PersistentClient (default: "./chroma") Use persistent storage when no host provided Default collection name for operations Direct configuration dictionary to load settings from Path to YAML configuration file Additional parameters including ssl, tracing\_project\_name ### Methods #### create\_collection Create a new collection in the Chroma database. ```python theme={null} create_collection( name: str, configuration: Optional[CollectionConfiguration] = None, metadata: Optional[CollectionMetadata] = None, embedding_function: Optional[EmbeddingFunction[Embeddable]] = None, get_or_create: bool = True, **kwargs: Any ) -> None ``` Unique identifier for the collection Collection-specific configuration object Metadata to associate with the collection Function to generate embeddings. Uses DefaultEmbeddingFunction if not provided If True, retrieves existing collection if it exists. If False, raises error if collection exists #### upsert Insert or update documents in the current collection. ```python theme={null} upsert( data: Union[List[Any], Dict[str, Any]], **kwargs: Any ) -> None ``` Either a list of Haystack Documents or a dictionary with keys: ids, documents/texts, metadatas, embeddings #### query Query the collection for similar vectors. ```python theme={null} query( query_embedding: Optional[list[float]] = None, query_text: Optional[str] = None, n_results: int = 10, where: Optional[dict[str, Any]] = None, where_document: Optional[dict[str, Any]] = None, include: List[str] = None, include_vectors: bool = False, **kwargs: Any ) -> dict[str, Any] ``` Vector embedding to search for Raw text to embed and search for Maximum number of results to return Metadata filter conditions (Chroma filter syntax) Document content filter conditions List of fields to include in results. Defaults to \["metadatas", "documents", "distances"] Whether to include embeddings in results List of document IDs List of document contents List of metadata dictionaries List of distance scores List of vectors (if include\_vectors=True) #### delete\_collection Delete a collection from the Chroma database. ```python theme={null} delete_collection(name: Optional[str] = None) -> None ``` Name of collection to delete. Uses default collection\_name if not provided #### flatten\_metadata Recursively flatten nested metadata for Chroma compatibility. ```python theme={null} flatten_metadata(metadata: Dict[str, Any]) -> Dict[str, Any] ``` Dictionary potentially containing nested dictionaries, lists, or complex types Flattened dictionary compatible with Chroma metadata storage. Nested keys use dot notation (e.g., "parent.child.key") *** ## MilvusVectorDB Interface for interacting with Milvus/Zilliz vector databases with support for dense vectors, sparse vectors, and hybrid search. ### Constructor ```python theme={null} MilvusVectorDB( uri: str = "http://localhost:19530", token: str = "", host: Optional[str] = None, port: Optional[str] = None, collection_name: Optional[str] = None, **kwargs ) ``` Milvus server URI. Use "[http://localhost:19530](http://localhost:19530)" for local Milvus or "https\://..." for Zilliz Cloud endpoints API token for Zilliz Cloud authentication. Leave empty for local Milvus or when using no authentication Deprecated. Use uri instead. Maintained for backward compatibility Deprecated. Use uri instead. Maintained for backward compatibility Default collection name for operations. Can be overridden per-method ### Methods #### create\_collection Create a Milvus collection with comprehensive schema for document storage. ```python theme={null} create_collection( collection_name: str, dimension: int, description: str = "", use_sparse: bool = False, use_partition_key: bool = False, partition_key_field: str = "namespace", recreate: bool = False ) ``` Unique name for the collection Dimensionality of dense embedding vectors. Must match the embedding model used (e.g., 768 for most transformer models) Human-readable description of the collection's purpose Whether to include a sparse vector field for hybrid search. Adds storage overhead but enables keyword matching alongside semantic search Whether to enable physical data partitioning. Enables efficient multi-tenancy by isolating data at the partition level Name of the partition key field. Documents with the same partition key value are routed to the same physical partition If True, drops existing collection with the same name before creating new one. Use with caution in production #### search Perform semantic search with support for dense, sparse, or hybrid retrieval. ```python theme={null} search( query_embedding: Optional[List[float]] = None, query_sparse_embedding: Optional[Union[Dict[int, float], SparseEmbedding]] = None, top_k: int = 10, collection_name: Optional[str] = None, filters: Optional[Dict[str, Any]] = None, scope: Optional[str] = None, namespace: Optional[str] = None, partition_key_field: str = "namespace", ranker_type: str = "rrf", weights: Optional[List[float]] = None, include_vectors: bool = False ) -> List[Document] ``` Dense query vector for semantic search. Typically from a text embedding model (e.g., 768-dim) Sparse query vector for keyword search. Can be Dict\[int, float] mapping term IDs to weights, or Haystack SparseEmbedding Maximum number of results to return Target collection. Uses default from constructor if None Metadata filter conditions as nested dict. Supports operators: $eq (equality), $gt/$lt (range), $in (list membership), \$contains (JSON contains) Unified tenant/partition identifier. Preferred over 'namespace' as it clearly conveys the isolation concept Legacy alias for scope. Partition key value for data isolation. Only used if scope is not provided Name of the partition key field in schema. Used to construct partition filter expressions Reranking strategy for hybrid search. "rrf" uses Reciprocal Rank Fusion (k=60 constant). "weighted" uses explicit weights Two-element list \[dense\_weight, sparse\_weight] for weighted ranker. Only used when ranker\_type="weighted". Defaults to \[0.5, 0.5] If True, includes embedding vectors in returned Documents. Increases response size but useful for downstream processing List of Haystack Document objects ordered by relevance score (descending). Documents include content, metadata, score, and optionally embeddings *** ## PineconeVectorDB Production-ready interface for Pinecone vector database operations with support for hybrid search and multi-tenancy. ### Constructor ```python theme={null} PineconeVectorDB( api_key: Optional[str] = None, index_name: Optional[str] = None, config: Optional[Dict[str, Any]] = None, config_path: Optional[str] = None, **kwargs ) ``` Pinecone API key for authentication Name of the Pinecone index to operate on Direct configuration dictionary Path to YAML configuration file Additional connection parameters (host, proxy\_url, ssl\_verify, pool\_threads) ### Methods #### create\_index Create a new Pinecone index or ensure an existing one is ready. ```python theme={null} create_index( dimension: Optional[int] = None, metric: str = "cosine", spec: Optional[Union[Dict[str, Any], ServerlessSpec]] = None, recreate: bool = False, index_name: Optional[str] = None, **kwargs ) -> None ``` Dimensionality of the vectors. Required for new indexes Distance metric for similarity calculations. Options: "cosine", "euclidean", "dotproduct" ServerlessSpec or dict defining cloud provider and region. Defaults to AWS us-east-1 serverless if not provided If True, delete existing index before creating new one Override the index name from **init** for this operation #### query Query the index for similar vectors. ```python theme={null} query( vector: List[float], top_k: int = 10, filter: Optional[Dict[str, Any]] = None, namespace: str = "", scope: Optional[str] = None, include_metadata: bool = True, include_values: bool = False, include_vectors: bool = False ) -> List[Any] ``` Query dense embedding vector Number of results to return Metadata filters to apply Namespace to search in (legacy parameter) Unified scope/namespace parameter (preferred over namespace) Whether to include metadata in results Whether to include vector values in results (legacy parameter) Whether to include vector values in results (preferred parameter) List of Haystack Documents with content, metadata, and optional embeddings #### flatten\_metadata Transform nested metadata into Pinecone-compatible flat structure. ```python theme={null} flatten_metadata(metadata: Dict[str, Any]) -> Dict[str, Any] ``` Potentially nested dictionary with arbitrary values Flat dictionary with only Pinecone-supported types. Nested dictionaries use underscore notation (e.g., user.id becomes user\_id)