## Performance evidence update / 18 September 2026

MODALITY PERFORMANCE / EVIDENCE REVIEWED 18 SEPTEMBER 2026

Choose the recall your application needs.
Measured local service comparison
September 18, 2026 article
Minimum recall@10
99%
99.5%
99.9%
99.98%
searches / second
Higher is better · linear scale from zero
8DB
8,551
Actual recall 99.043%
Qdrant
4,682
Actual recall 99.531%

99,488 real 768D passage embeddings; 512 queries, top 10, eight clients, 2 GiB server cap. Warmed, unfiltered retrieval on a shared workstation; different transports and unmatched persistence/governance. Fastest tested setting meeting each floor, not equal actual recall. Qdrant built faster and leads at the strictest shown floor.

Read the results, comparison and methods →
Index-ready time in the main campaign

8DB: 166 s with one construction thread. Qdrant: 18.3 s with up to eight, persisted. Later 8DB build tuning is a separate calibration, not the same configuration as the best search result.

01
Recall at declared k
02
Tail latency & build time
03
Build / serving memory
Include memory, storage, energy and hardware writes

[Read the results, comparison and methods →](/journal/j-fd809ca5f5f1)

<!-- performance-update-end -->

## Implementation update — 18 September 2026


Implementation snapshot / Reviewed 18 September 2026

Keep the typed contributions behind a ranked result.

Documented native composition fixture

The engineering guide points to a persisted composition regression combining stored text, dense retrieval and a typed table contribution. It explicitly distinguishes ranked fusion from a general relational join, so an application can retain the richer outputs instead of treating every result as only a score.
[Explore the complete retrieval workload →](/outcomes/evidence-retrieval#workload)

API, release scope and evidence limits

Native search guide: native_search_persisted_execution.rs, composition example at 7daa7908. PersistentSearchOutput exposes compatibility ranking and native contributions.

Documentary review on 18 September 2026, not a new vector benchmark. Confirm the actual dimensions, metric, filters, recall, model-generation path, build and platform for your evaluation. The broader search release gates remain open in the reviewed records.



---

# Vectors & similarity | 8DB

Product reference. Reviewed 18 September 2026. Implementation and evaluation scope are stated below.

Explore the models

(https://8braid.com/modalities)

/ 8DB

Vectors & similarity

Give a similar result its context.

Find candidates through vector and hybrid retrieval, then connect them to source records and the relationships that make them useful.

Explore the capabilities

See a complete workload

Compare · rank · retrieve

Model /

Vectors

Conceptual diagram

[Diagram: vectors representation: conceptual diagram]

A query vector sits among candidate neighbors. Distance is illustrative, not measured retrieval quality.

Capabilities

What changes

Input to value

Alternatives

Performance

Adoption

Related articles

Reference

Capabilities / documented scope

Find by meaning.

Keep the exact details in play.

01 / Similarity

Find related material

Cosine similarity compares vector representations. An embedding model supplies those vectors; its version, dimensions and normalization define what the comparison means.

02 / Retrieval

Search a larger candidate space

Supported approximate-neighbor paths retrieve candidate matches. Evaluate the balance between recall, response time and memory on your corpus.

03 / Hybrid

Combine meaning with exact terms

Sparse and dense retrieval fusion brings different signals into candidate selection. Product codes, names and specialist vocabulary can matter alongside semantic similarity.

Documentary review, 18 September 2026 UTC. Supported index, filter, persistence and API combinations must be checked against the build selected for evaluation. Similarity is a retrieval signal, not a truth score.

Why consider 8DB / connected native models

Give the match its missing context.

The source, the asset and the moment can each change which result is useful.

[Diagram: documents representation: conceptual diagram]

documents

The source

Read the passage behind the match.

Explore model ↗

(https://8braid.com/modalities/documents)

[Diagram: graphs representation: conceptual diagram]

graphs

The relationships

Check the asset and its configuration.

Explore model ↗

(https://8braid.com/modalities/graphs)

[Diagram: time series representation: conceptual diagram]

time-series

The moment

Bring dated observations into view.

Explore model ↗

(https://8braid.com/modalities/time-series)

Conceptual model connections. 8DB offers these native representations; fewer handoffs and simpler application assembly are opportunities to test on the supported combination.

Input → usable value / interactive design example

Follow a question all the way to a usable answer.

0

1

Describe the problem

→

0

2

Find candidates

→

0

3

Connect the context

→

0

4

Return usable evidence

→

[Diagram: documents representation: conceptual diagram]

Step

1

/

documents

“P-17 vibrates after servicing”

Start with an incident description and the identity of the equipment. The embedding model represents the query.

Next: Find candidates

Illustrative application design, not an executed benchmark. Qualify the composed path, including external models, authorization, persistence and update visibility.

What belongs in the complete-workflow comparison?

Measure from the declared input state to the usable output, including required parsing, embeddings, storage, index readiness, querying and result assembly. Report database-stage timing separately. Include memory, storage, network and measured energy when relevant.

Market context

Choose for the whole retrieval job.

Approach

What it brings

What to compare with 8DB

Qdrant

(https://qdrant.tech/documentation/search/hybrid-queries/)

Hybrid and multistage retrieval, including dense/sparse fusion.

Candidate quality, filtering and reranking, then the work needed to assemble source and relationship context.

PostgreSQL + pgvector

(https://github.com/pgvector/pgvector)

Vector search inside PostgreSQL, with HNSW and IVFFlat index options.

Existing SQL investment, speed/recall tradeoffs, filtered retrieval and the broader application's data shapes.

SurrealDB

(https://surrealdb.com/docs/learn/data-models)

An integrated data-model offering spanning records, documents, graphs and vectors.

The exact operations, deployment, protection and cross-model workload you need.

8DB

Vector and hybrid retrieval alongside its wider native modality family.

Whether the supported combination reduces application assembly while meeting quality, freshness and resource targets.

Vendor documentation reviewed 18 September 2026 UTC. Capability context, not a measured ranking. Hybrid search and multiple models are established market capabilities; the evaluation should test the combination that matters to your application.

Performance & resources

Measure the work that delivers the answer.

Recall or relevance at a declared corpus/model; p95 useful-response latency; filter selectivity; ingest-to-search freshness; embedding/index time; memory, disk, network and measured energy.

Published results apply to the named operation, build and workload. The evaluation below separates a component result from the database service and the complete application outcome.

01

Retrieval quality

Recall at a declared corpus, embedding model and eligible subset. Test selective filters and changing records.

02

Useful response

p95 and p99 latency at a declared load, including source assembly and any required reranking.

03

Operating cost

Build and update time, index freshness, peak memory, disk bytes and measured energy per successful job.

Explore the published benchmark evidence

(https://8braid.com/benchmarks)

What belongs inside the timer and resource budget?

For input-to-value testing, declare the input state and the consumer-ready output first. Include parsing, derivation, storage/protection, index readiness, querying, result assembly and delivery as applicable. Identify amortized setup and any work deferred past the finish line.

Report database-stage and full-job results separately. Do not add unrelated medians or p95 values, or multiply component speedups into a claimed workflow result. Energy needs measured joules; reduced handoffs alone do not establish a saving.

Choose the path that fits your deployment.

Verify the supported API/SDK, data format, persistence and indexing behaviour for the release you plan to use. Match the operation-by-modality protection profile and device qualification to the workload.

Post-quantum protection

(https://8braid.com/pqc)

·

Plan a workload evaluation

(https://8braid.com/build)

Related articles

Take the next step into the thinking.

Mechanism & application

Give Your AI the Evidence Behind the Answer

(https://8braid.com/journal/the-database-is-part-of-the-model)

Explore the ideas and implementation context behind this capability.

Mechanism & application

Show Your Work: Provenance as a Query, Not a Forensic Reconstruction

(https://8braid.com/journal/show-your-work-provenance-as-a-query)

Explore the ideas and implementation context behind this capability.

Reference / Reviewed 18 September 2026 UTC

Readable, shareable and traceable.

This reference explains

8DB’s public modality description

(https://8braid.com/modalities#explore)

with an explicit workload and selection criteria. It is a documentary review, not fresh execution of every operator or platform.

Public sources include the linked vendor documentation in the comparison above. Additional context:

8DB modality scope

(https://8braid.com/modalities)

;

Qdrant hybrid queries

(https://qdrant.tech/documentation/search/hybrid-queries/)

; the related articles above. Internal source leads and outstanding release checks remain in the editorial record.

Download this reference

(https://8braid.com/modality-reference/vectors.md)

Evaluate the question

your application needs to answer.

Bring the data shapes, input state, expected output and the systems you use today. Define a comparison around that complete job.

Discuss your workload

(https://8braid.com/build)
