Vector Databases (Java)

Prerequisites

Complete the Java SDK setup first. For Pinecone, see the dedicated Pinecone page.

Qdrant

Wraps io.qdrant.client.QdrantClient. All operations are async internally (the wrapper calls .get() on futures).

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-qdrant</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-qdrant:main-SNAPSHOT'

import ai.traceai.qdrant.TracedQdrantClient;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;

QdrantClient client = new QdrantClient(
    QdrantGrpcClient.newBuilder("localhost", 6334, false).build()
);
TracedQdrantClient traced = new TracedQdrantClient(client);

// Search
var results = traced.search("my-collection", queryVector, 10);

// Upsert
traced.upsert("my-collection", pointsList);

// Create collection
traced.createCollection("my-collection", 1536, Distance.Cosine);

Spans: “Qdrant Search” (RETRIEVER), “Qdrant Upsert” (VECTOR_DB), “Qdrant Create Collection” (VECTOR_DB), “Qdrant Delete” (VECTOR_DB), “Qdrant Get” (VECTOR_DB), “Qdrant List Collections” (VECTOR_DB)

Extra attributes: qdrant.top_score, qdrant.has_filter, qdrant.distance, qdrant.status

Milvus

Wraps io.milvus.v2.client.MilvusClientV2. Uses SDK v2 request objects throughout.

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-milvus</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-milvus:main-SNAPSHOT'

import ai.traceai.milvus.TracedMilvusClient;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.*;

MilvusClientV2 client = new MilvusClientV2(/* config */);
TracedMilvusClient traced = new TracedMilvusClient(client);

// ANN search
var results = traced.search(SearchReq.builder()
    .collectionName("my-collection")
    .data(List.of(queryVector))
    .topK(10)
    .build());

// Scalar/filtered query
var queryResults = traced.query(QueryReq.builder()
    .collectionName("my-collection")
    .filter("category == 'science'")
    .build());

// Insert
traced.insert(InsertReq.builder()
    .collectionName("my-collection")
    .data(documents)
    .build());

Spans: “Milvus Search” (RETRIEVER), “Milvus Query” (RETRIEVER), “Milvus Insert” (VECTOR_DB), “Milvus Upsert” (VECTOR_DB), “Milvus Delete” (VECTOR_DB), “Milvus Get” (VECTOR_DB)

Extra attributes: milvus.top_score, milvus.filter, milvus.inserted_count, milvus.query_vectors_count

ChromaDB

Wraps tech.amikos.chromadb.Collection. Text-based queries only (the SDK v0.1.7 doesn’t support raw vector queries).

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-chromadb</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-chromadb:main-SNAPSHOT'

import ai.traceai.chromadb.TracedChromaCollection;
import tech.amikos.chromadb.Collection;

Collection collection = /* get from ChromaDB client */;
TracedChromaCollection traced = new TracedChromaCollection(collection, "my-collection");

// Query by text
var results = traced.query(
    List.of("What is machine learning?"),  // query texts
    10,                                     // nResults
    null,                                   // where filter
    null,                                   // whereDocument filter
    List.of(IncludeEnum.DOCUMENTS, IncludeEnum.DISTANCES)
);

// Add documents
traced.add(embeddings, metadatas, documents, ids);

Spans: “ChromaDB Query” (RETRIEVER), “ChromaDB Add” (VECTOR_DB), “ChromaDB Upsert” (VECTOR_DB), “ChromaDB Delete” (VECTOR_DB), “ChromaDB Get” (VECTOR_DB), “ChromaDB Count” (VECTOR_DB)

Extra attributes: chromadb.top_distance (distance, not similarity score - ChromaDB is distance-based)

Weaviate

Wraps io.weaviate.client.WeaviateClient. Uses “class name” terminology instead of “collection”.

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-weaviate</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-weaviate:main-SNAPSHOT'

import ai.traceai.weaviate.TracedWeaviateClient;
import io.weaviate.client.WeaviateClient;

WeaviateClient client = new WeaviateClient(/* config */);
TracedWeaviateClient traced = new TracedWeaviateClient(client);

// Vector search (uses Float[] not List<Float>)
var results = traced.nearVectorSearch("Article", vectorArray, 10, "title", "content");

// Create object
traced.createObject("Article", properties, vectorArray);

// Batch import (varargs - pass individual objects or convert list to array)
traced.batchImport(obj1, obj2, obj3);

Spans: “Weaviate NearVector Search” (RETRIEVER), “Weaviate Create Object” (VECTOR_DB), “Weaviate Batch Import” (VECTOR_DB), “Weaviate Delete Object” (VECTOR_DB), “Weaviate Get Object” (VECTOR_DB)

Extra attributes: weaviate.object_id, weaviate.imported_count, weaviate.has_errors

MongoDB Atlas Vector Search

Wraps com.mongodb.client.MongoCollection<Document>. Builds the $vectorSearch aggregation pipeline internally.

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-mongodb</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-mongodb:main-SNAPSHOT'

import ai.traceai.mongodb.TracedMongoVectorSearch;
import com.mongodb.client.MongoCollection;
import org.bson.Document;

MongoCollection<Document> collection = /* your MongoDB collection */;
TracedMongoVectorSearch traced = new TracedMongoVectorSearch(collection, "my-collection");

// Vector search (uses List<Double>, not List<Float>)
var results = traced.vectorSearch(
    queryVectorDoubles,  // List<Double>
    "embedding",         // vector field path
    "vector_index",      // Atlas Search index name
    10,                  // limit
    100                  // numCandidates
);

// Insert
traced.insertOne(new Document("text", "hello").append("embedding", vectorDoubles));

Spans: “MongoDB Vector Search” (RETRIEVER), “MongoDB Insert” (VECTOR_DB), “MongoDB Insert Many” (VECTOR_DB), “MongoDB Delete” (VECTOR_DB)

Extra attributes: mongodb.num_candidates, mongodb.path, mongodb.top_score

Note: the wrapper constructs the $vectorSearch aggregation pipeline for you and appends vectorSearchScore to results.

Redis

Wraps redis.clients.jedis.JedisPooled. Builds KNN query strings and handles byte conversion internally.

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-redis</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-redis:main-SNAPSHOT'

import ai.traceai.redis.TracedRedisVectorSearch;
import redis.clients.jedis.JedisPooled;

JedisPooled jedis = new JedisPooled("localhost", 6379);
TracedRedisVectorSearch traced = new TracedRedisVectorSearch(jedis);

// Create index
traced.createIndex("my-index", "embedding", 1536, "FLOAT32", "COSINE");

// Add document (float[] for vector)
traced.addDocument("doc:1", vectorArray, Map.of("title", "Hello"));

// Search (float[] for query vector)
var results = traced.vectorSearch("my-index", queryVectorArray, 10);

Spans: “Redis Create Index” (VECTOR_DB), “Redis Vector Search” (RETRIEVER), “Redis Add Document” (VECTOR_DB), “Redis Delete Document” (VECTOR_DB)

Extra attributes: redis.vector_field, redis.distance_metric, redis.algorithm

pgvector

Wraps javax.sql.DataSource or java.sql.Connection directly. Handles table creation, indexing, search with all three distance functions, and batch operations.

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-pgvector</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-pgvector:main-SNAPSHOT'

import ai.traceai.pgvector.TracedPgVectorStore;
import javax.sql.DataSource;

DataSource ds = /* your PostgreSQL DataSource */;
TracedPgVectorStore traced = new TracedPgVectorStore(ds);

// Create table
traced.createTable("documents", 1536);

// Create index (supports ivfflat and hnsw)
traced.createIndex("documents", "hnsw", 100);

// Insert
traced.insert("documents", "doc-1", vectorArray, Map.of("title", "Hello"));

// Search (supports L2, cosine, inner product)
var results = traced.search("documents", queryVectorArray, 10, "cosine");

// Search with filter
var filtered = traced.searchWithFilter("documents", queryVectorArray, 10, "cosine", "title = 'Hello'");

Spans: “PgVector Search” (RETRIEVER), “PgVector Insert” (VECTOR_DB), “PgVector Batch Insert” (VECTOR_DB), “PgVector Create Table” (VECTOR_DB), “PgVector Create Index” (VECTOR_DB), plus delete, count, and drop operations.

Extra attributes: pgvector.distance_function, pgvector.index_type, pgvector.has_filter

Distance operators: <-> (L2), <=> (cosine), <#> (inner product)

Azure AI Search

Wraps com.azure.search.documents.SearchClient. The only vector DB with hybrid (text + vector) search support.

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-azure-search</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-azure-search:main-SNAPSHOT'

import ai.traceai.azure.search.TracedSearchClient;
import com.azure.search.documents.SearchClient;

SearchClient searchClient = /* build with Azure credentials */;
TracedSearchClient traced = new TracedSearchClient(searchClient, "my-index");

// Pure vector search
var results = traced.searchWithVector("", queryVector, "contentVector", 10);

// Hybrid search (text + vector)
var hybrid = traced.hybridSearch("machine learning", queryVector, "contentVector", 10);

// Text-only search
var textResults = traced.search("machine learning", 10);

// Upload documents
traced.uploadDocuments(documents);

Spans: “Azure Search Vector Query” (RETRIEVER), “Azure Search Hybrid Query” (RETRIEVER), “Azure Search Text Query” (RETRIEVER), “Azure Search Upload Documents” (VECTOR_DB), plus merge, delete, get, and count operations.

Extra attributes: azure_search.search_mode (vector/hybrid/text), azure_search.top_score, azure_search.success_count, azure_search.failed_count

Elasticsearch

Wraps co.elastic.clients.elasticsearch.ElasticsearchClient. KNN search with optional query filtering.

<dependency>
    <groupId>com.github.future-agi.traceAI</groupId>
    <artifactId>traceai-java-elasticsearch</artifactId>
    <version>main-SNAPSHOT</version>
</dependency>

implementation 'com.github.future-agi.traceAI:traceai-java-elasticsearch:main-SNAPSHOT'

import ai.traceai.elasticsearch.TracedElasticsearchClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;

ElasticsearchClient client = /* build with RestClient */;
TracedElasticsearchClient traced = new TracedElasticsearchClient(client);

// KNN search
var results = traced.knnSearch("my-index", queryVectorArray, 10, 100, "embedding");

// KNN with filter
var filtered = traced.knnSearchWithFilter("my-index", queryVectorArray, 10, 100, "embedding", filterQuery);

// Index document
traced.index("my-index", "doc-1", Map.of("text", "hello", "embedding", vectorArray));

// Bulk index
traced.bulkIndex("my-index", documents);

Spans: “Elasticsearch KNN Search” (RETRIEVER), “Elasticsearch KNN Search with Filter” (RETRIEVER), “Elasticsearch Index Document” (VECTOR_DB), “Elasticsearch Bulk Index” (VECTOR_DB), “Elasticsearch Delete Document” (VECTOR_DB), “Elasticsearch Create Index” (VECTOR_DB)

Extra attributes: elasticsearch.num_candidates, elasticsearch.total_hits, elasticsearch.took_ms, elasticsearch.field

Common span attributes

All vector database wrappers capture: