Frameworks on Qdrant - Vector Database

Agno

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Agno

Agno is an incredibly fast multi-agent framework, runtime and UI. It enables you to build multi-agent systems with memory, knowledge, human-in-the-loop capabilities, and Model Context Protocol (MCP) support.

You can orchestrate agents as multi-agent teams (providing more autonomy) or step-based agentic workflows (offering more control). Agno works seamlessly with Qdrant as a vector database for knowledge bases, enabling efficient storage and retrieval of information for your AI agents.

AutoGen

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Microsoft AutoGen

AutoGen is an open-source programming framework for building AI agents and facilitating cooperation among multiple agents to solve tasks.

Multi-agent conversations: AutoGen agents can communicate with each other to solve tasks. This allows for more complex and sophisticated applications than would be possible with a single LLM.
Customization: AutoGen agents can be customized to meet the specific needs of an application. This includes the ability to choose the LLMs to use, the types of human input to allow, and the tools to employ.

AWS Lakechain

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

AWS Lakechain

Project Lakechain is a framework based on the AWS Cloud Development Kit (CDK), allowing to express and deploy scalable document processing pipelines on AWS using infrastructure-as-code. It emphasizes on modularity and extensibility of pipelines, and provides 60+ ready to use components for prototyping complex processing pipelines that scale out of the box to millions of documents.

The Qdrant storage connector available with Lakechain enables uploading vector embeddings produced by other middlewares to a Qdrant collection.

CamelAI

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Camel

Camel is a Python framework to build and use LLM-based agents for real-world task solving.

Qdrant is available as a storage mechanism in Camel for ingesting and retrieving semantically similar data.

Usage With Qdrant

Install Camel with the vector-databases extra.

pip install "camel[vector-databases]"

Configure the QdrantStorage class.

from camel.storages import QdrantStorage, VectorDBQuery, VectorRecord
from camel.types import VectorDistance

qdrant_storage = QdrantStorage(
 url_and_api_key=(
 "https://xyz-example.eu-central.aws.cloud.qdrant.io:6333",
 "<provide-your-own-key>",
 ),
 collection_name="{collection_name}",
 distance=VectorDistance.COSINE,
 vector_dim=384,
)

The QdrantStorage class implements methods to read and write to a Qdrant instance. An instance of this class can now be passed to retrievers for interfacing with your Qdrant collections.

Cheshire Cat

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Cheshire Cat

Cheshire Cat is an open-source framework that allows you to develop intelligent agents on top of many Large Language Models (LLM). You can develop your custom AI architecture to assist you in a wide range of tasks.

Cheshire Cat and Qdrant

Cheshire Cat uses Qdrant as the default Vector Memory for ingesting and retrieving documents.

# Decide host and port for your Cat. Default will be localhost:1865
CORE_HOST=localhost
CORE_PORT=1865

# Qdrant server
# QDRANT_HOST=localhost
# QDRANT_PORT=6333

Cheshire Cat takes great advantage of the following features of Qdrant:

Cognee

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Cognee

Embeddings make it easy to retrieve similar chunks of information — but most agent tasks require more: structure, temporal context, and cross-document reasoning. That’s where Cognee comes in: it turns raw data sources into AI memory —a semantic data layer based on a modular, queryable knowledge graph backed by embeddings, so agents can retrieve, reason, and remember with structure.

Why Qdrant For The Memory Layer

At runtime, Cognee’s semantic memory layer requires fast and predictable lookups to surface candidates for graph reasoning, as well as tight control over metadata to ground multi-hop traversals. Qdrant’s design aligns with those needs with its:

CrewAI

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

CrewAI

CrewAI is a framework for orchestrating role-playing, autonomous AI agents. By leveraging collaborative intelligence, CrewAI allows agents to work together seamlessly, tackling complex tasks.

The framework has a sophisticated memory system designed to significantly enhance the capabilities of AI agents. This system aids agents to remember, reason, and learn from past interactions. You can use Qdrant to store short-term memory and entity memories of CrewAI agents.

Short-Term Memory

Temporarily stores recent interactions and outcomes using RAG, enabling agents to recall and utilize information relevant to their current context during the current executions.

Dagster

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Dagster

Dagster is a Python framework for data orchestration built for data engineers, with integrated lineage, observability, a declarative programming model, and best-in-class testability.

The dagster-qdrant library lets you integrate Qdrant’s vector database with Dagster, making it easy to build AI-driven data pipelines. You can run vector searches and manage data directly within Dagster.

Installation

pip install dagster dagster-qdrant

Example

from dagster_qdrant import QdrantConfig, QdrantResource

import dagster as dg


@dg.asset
def my_table(qdrant_resource: QdrantResource):
 with qdrant_resource.get_client() as qdrant:
 qdrant.add(
 collection_name="test_collection",
 documents=[
 "This is a document about oranges",
 "This is a document about pineapples",
 "This is a document about strawberries",
 "This is a document about cucumbers",
 ],
 )
 results = qdrant.query(
 collection_name="test_collection", query_text="hawaii", limit=3
 )


defs = dg.Definitions(
 assets=[my_table],
 resources={
 "qdrant_resource": QdrantResource(
 config=QdrantConfig(
 host="xyz-example.eu-central.aws.cloud.qdrant.io",
 api_key="<your-api-key>",
 )
 )
 },
)

Next steps

Dagster documentation

DeepEval

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

DeepEval

DeepEval by Confident AI is an open-source framework for testing large language model systems. Similar to Pytest but designed for LLM outputs, it evaluates metrics like G-Eval, hallucination, answer relevancy.

DeepEval can be integrated with Qdrant to evaluate RAG pipelines — ensuring your LLM applications return relevant, grounded, and faithful responses based on retrieved vector search context.

How it works

A test case is a blueprint provided by DeepEval to unit test LLM outputs. There are two types of test cases in DeepEval:

Dynamiq

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Dynamiq

Dynamiq is your all-in-one Gen AI framework, designed to streamline the development of AI-powered applications. Dynamiq specializes in orchestrating retrieval-augmented generation (RAG) and large language model (LLM) agents.

Qdrant is a vector database available in Dynamiq, capable of serving multiple roles. It can be used for writing and retrieving documents, acting as memory for agent interactions, and functioning as a retrieval tool that agents can call when needed.

Installing

First, ensure you have the dynamiq library installed:

Feast

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Feast

Feast (Feature Store) is an open-source feature store that helps teams operate production ML systems at scale by allowing them to define, manage, validate, and serve features for production AI/ML.

Qdrant is available as a supported vectorstore in Feast to integrate in your workflows.

Insatallation

To use the Qdrant online store, you need to install Feast with the qdrant extra.

pip install 'feast[qdrant]'

Usage

An example config with Qdrant could look like:

FiftyOne

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

FiftyOne

FiftyOne is an open-source toolkit designed to enhance computer vision workflows by optimizing dataset quality and providing valuable insights about your models. FiftyOne 0.20, which includes a native integration with Qdrant, supporting workflows like image similarity search and text search.

Qdrant helps FiftyOne to find the most similar images in the dataset using vector embeddings.

FiftyOne is available as a Python package that might be installed in the following way:

Firebase Genkit

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Firebase Genkit

Genkit is a framework to build, deploy, and monitor production-ready AI-powered apps.

You can build apps that generate custom content, use semantic search, handle unstructured inputs, answer questions with your business data, autonomously make decisions, orchestrate tool calls, and more.

You can use Qdrant for indexing/semantic retrieval of data in your Genkit applications via the Qdrant-Genkit plugin.

Genkit currently supports server-side development in JavaScript/TypeScript (Node.js) with Go support in active development.

Google ADK

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Google ADK

Agent Development Kit (ADK) is an open-source, code-first Python framework from Google for building, evaluating, and deploying sophisticated AI agents. While optimized for Gemini, ADK is model-agnostic and compatible with other frameworks.

You can connect ADK agents to Qdrant using the Qdrant MCP Server, giving your agent the ability to store and retrieve information using semantic search.

Installation

pip install google-adk

Usage

from google.adk.agents import Agent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StdioConnectionParams
from mcp import StdioServerParameters

QDRANT_URL = "http://localhost:6333"
COLLECTION_NAME = "my_collection"

root_agent = Agent(
 model="gemini-2.5-pro",
 name="qdrant_agent",
 instruction="Help users store and retrieve information using semantic search",
 tools=[
 McpToolset(
 connection_params=StdioConnectionParams(
 server_params=StdioServerParameters(
 command="uvx",
 args=["mcp-server-qdrant"],
 env={
 "QDRANT_URL": QDRANT_URL,
 "COLLECTION_NAME": COLLECTION_NAME,
 }
 ),
 timeout=30,
 ),
 )
 ],
)

For available tools and configuration options, see the Qdrant MCP Server documentation.

Haystack

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Haystack

Haystack serves as a comprehensive NLP framework, offering a modular methodology for constructing cutting-edge generative AI, QA, and semantic knowledge base search systems. A critical element in contemporary NLP systems is an efficient database for storing and retrieving extensive text data. Vector databases excel in this role, as they house vector representations of text and implement effective methods for swift retrieval. Thus, we are happy to announce the integration with Haystack - QdrantDocumentStore. This document store is unique, as it is maintained externally by the Qdrant team.

HoneyHive

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

HoneyHive

HoneyHive is an AI evaluation and observability platform for Generative AI applications. HoneyHive’s platform gives developers enterprise-grade tools to debug complex retrieval pipelines, evaluate performance over large test suites, monitor usage in real-time, and manage prompts within a shared workspace. Teams use HoneyHive to iterate faster, detect failures at scale, and deliver exceptional AI products.

By integrating Qdrant with HoneyHive, you can:

Trace vector database operations
Monitor latency, embedding quality, and context relevance
Evaluate retrieval performance in your RAG pipelines
Optimize paramaters such as chunk_size or chunk_overlap

Prerequisites

A HoneyHive account and API key
Python 3.8+

Installation

Install the required packages:

LangChain

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

LangChain

LangChain is a library that makes developing Large Language Model-based applications much easier. It unifies the interfaces to different libraries, including major embedding providers and Qdrant. Using LangChain, you can focus on the business value instead of writing the boilerplate.

LangChain distributes the Qdrant integration as a partner package.

It might be installed with pip:

pip install langchain-qdrant

The integration supports searching for relevant documents usin dense/sparse and hybrid retrieval.

LangChain4j

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

LangChain for Java

LangChain for Java, also known as Langchain4J, is a community port of Langchain for building context-aware AI applications in Java

You can use Qdrant as a vector store in LangChain4j through the langchain4j-qdrant module.

Setup

Add the langchain4j-qdrant to your project dependencies.

<dependency>
 <groupId>dev.langchain4j</groupId>
 <artifactId>langchain4j-qdrant</artifactId>
 <version>VERSION</version>
</dependency>

Usage

Before you use the following code sample, customize the following values for your configuration:

YOUR_COLLECTION_NAME: Use our Collections guide to create or list collections.
YOUR_HOST_URL: Use the GRPC URL for your system. If you used the Quick Start guide, it may be http://localhost:6334. If you’ve deployed in the Qdrant Cloud, you may have a longer URL such as https://example.location.cloud.qdrant.io:6334.
YOUR_API_KEY: Substitute the API key associated with your configuration.

import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.qdrant.QdrantEmbeddingStore;

EmbeddingStore<TextSegment> embeddingStore =
 QdrantEmbeddingStore.builder()
 // Ensure the collection is configured with the appropriate dimensions
 // of the embedding model.
 // Reference https://qdrant.tech/documentation/concepts/collections/
 .collectionName("YOUR_COLLECTION_NAME")
 .host("YOUR_HOST_URL")
 // GRPC port of the Qdrant server
 .port(6334)
 .apiKey("YOUR_API_KEY")
 .build();

QdrantEmbeddingStore supports all the semantic features of LangChain4j.

LangGraph

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

LangGraph

LangGraph is a library for building stateful, multi-actor applications, ideal for creating agentic workflows. It provides fine-grained control over both the flow and state of your application, crucial for creating reliable agents.

You can define flows that involve cycles, essential for most agentic architectures, differentiating it from DAG-based solutions. Additionally, LangGraph includes built-in persistence, enabling advanced human-in-the-loop and memory features.

LangGraph works seamlessly with all the components of LangChain. This means we can utilize Qdrant’s Langchain integration to create retrieval nodes in LangGraph, available in both Python and Javascript!

LlamaIndex

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

LlamaIndex

Llama Index acts as an interface between your external data and Large Language Models. So you can bring your private data and augment LLMs with it. LlamaIndex simplifies data ingestion and indexing, integrating Qdrant as a vector index.

Installing Llama Index is straightforward if we use pip as a package manager. Qdrant is not installed by default, so we need to install it separately. The integration of both tools also comes as another package.

Mastra

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Mastra

Mastra is a Typescript framework to build AI applications and features quickly. It gives you the set of primitives you need: workflows, agents, RAG, integrations, syncs and evals. You can run Mastra on your local machine, or deploy to a serverless cloud.

Qdrant is available as a vector store in Mastra node to augment application with retrieval capabilities.

Setup

npm install @mastra/core

Usage

import { QdrantVector } from "@mastra/rag";

const qdrant = new QdrantVector({
 url: "https://xyz-example.eu-central.aws.cloud.qdrant.io:6333"
 apiKey: "<YOUR_API_KEY>",
 https: true
});

Constructor Options

Name	Type	Description
`url`	`string`	REST URL of the Qdrant instance. Eg. https://xyz-example.eu-central.aws.cloud.qdrant.io:6333
`apiKey`	`string`	Optional Qdrant API key
`https`	`boolean`	Whether to use TLS when setting up the connection. Recommended.

Methods

`createIndex()`

Name	Type	Description	Default Value
`indexName`	`string`	Name of the index to create
`dimension`	`number`	Vector dimension size
`metric`	`string`	Distance metric for similarity search	`cosine`

`upsert()`

Name	Type	Description
`vectors`	`number[][]`	Array of embedding vectors
`metadata`	`Record<string, any>[]`	Metadata for each vector (optional)
`namespace`	`string`	Optional namespace for organization

`query()`

Name	Type	Description	Default Value
`vector`	`number[]`	Query vector to find similar vectors
`topK`	`number`	Number of results to return (optional)	`10`
`filter`	`Record<string, any>`	Metadata filters for the query (optional)

`listIndexes()`

Returns an array of index names as strings.

Mem0

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Mem0 remembers user preferences, adapts to individual needs, and continuously improves over time, ideal for chatbots and AI systems.

Mem0 supports various vector store providers, including Qdrant, for efficient data handling and search capabilities.

Installation

To install Mem0 with Qdrant support, use the following command:

pip install mem0ai

Usage

Here’s a basic example of how to use Mem0 with Qdrant:

Microsoft NLWeb

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

NLWeb

Microsoft’s NLWeb is a proposed framework that enables natural language interfaces for websites, using Schema.org, formats like RSS and the emerging MCP protocol.

Qdrant is supported as a vector store backend within NLWeb for embedding storage and context retrieval.

Usage

NLWeb includes Qdrant integration by default. You can install and configure it to use Qdrant as the retrieval engine.

Installation

Clone the repo and set up your environment:

git clone https://github.com/microsoft/NLWeb
cd NLWeb
python -m venv .venv
source venv/bin/activate # or `venv\Scripts\activate` on Windows
cd code
pip install -r requirements.txt

Configuring Qdrant

To use Qdrant, update your configuration.

Neo4j GraphRAG

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Neo4j GraphRAG

Neo4j GraphRAG is a Python package to build graph retrieval augmented generation (GraphRAG) applications using Neo4j and Python. As a first-party library, it offers a robust, feature-rich, and high-performance solution, with the added assurance of long-term support and maintenance directly from Neo4j. It offers a Qdrant retriever natively to search for vectors stored in a Qdrant collection.

Installation

pip install neo4j-graphrag[qdrant]

Usage

A vector query with Neo4j and Qdrant could look like:

Rig-rs

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Rig-rs

Rig is a Rust library for building scalable, modular, and ergonomic LLM-powered applications. It has full support for LLM completion and embedding workflows with minimal boiler plate.

Rig supports Qdrant as a vectorstore to ingest and search for documents semantically.

Installation

cargo add rig-core rig-qdrant qdrant-client

Usage

Here’s an example ingest and retrieve flow using Rig and Qdrant.

use qdrant_client::{
 qdrant::{PointStruct, QueryPointsBuilder, UpsertPointsBuilder},
 Payload, Qdrant,
};
use rig::{
 embeddings::EmbeddingsBuilder,
 providers::openai::{Client, TEXT_EMBEDDING_3_SMALL},
 vector_store::VectorStoreIndex,
};
use rig_qdrant::QdrantVectorStore;
use serde_json::json;

const COLLECTION_NAME: &str = "rig-collection";

// Initialize Qdrant client.
let client = Qdrant::from_url("http://localhost:6334").build()?;
// Initialize OpenAI client.
let openai_client = Client::new("<OPENAI_API_KEY>");
let model = openai_client.embedding_model(TEXT_EMBEDDING_3_SMALL);

let documents = EmbeddingsBuilder::new(model.clone())
 .simple_document("0981d983-a5f8-49eb-89ea-f7d3b2196d2e", "Definition of a *flurbo*: A flurbo is a green alien that lives on cold planets")
 .simple_document("62a36d43-80b6-4fd6-990c-f75bb02287d1", "Definition of a *glarb-glarb*: A glarb-glarb is a ancient tool used by the ancestors of the inhabitants of planet Jiro to farm the land.")
 .simple_document("f9e17d59-32e5-440c-be02-b2759a654824", "Definition of a *linglingdong*: A term used by inhabitants of the far side of the moon to describe humans.")
 .build()
 .await?;

let points: Vec<PointStruct> = documents
 .into_iter()
 .map(|d| {
 let vec: Vec<f32> = d.embeddings[0].vec.iter().map(|&x| x as f32).collect();
 PointStruct::new(
 d.id,
 vec,
 Payload::try_from(json!({
 "document": d.document,
 }))
 .unwrap(),
 )
 })
 .collect();

client
 .upsert_points(UpsertPointsBuilder::new(COLLECTION_NAME, points))
 .await?;

let query_params = QueryPointsBuilder::new(COLLECTION_NAME).with_payload(true);
let vector_store = QdrantVectorStore::new(client, model, query_params.build());

let results = vector_store
 .top_n::<serde_json::Value>("Define a glarb-glarb?", 1)
 .await?;

println!("Results: {:?}", results);

Semantic-Router

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Semantic-Router

Semantic-Router is a library to build decision-making layers for your LLMs and agents. It uses vector embeddings to make tool-use decisions rather than LLM generations, routing our requests using semantic meaning.

Qdrant is available as a supported index in Semantic-Router for you to ingest route data and perform retrievals.

Installation

To use Semantic-Router with Qdrant, install the qdrant extra:

pip install semantic-router[qdrant]

Usage

Set up QdrantIndex with the appropriate configurations:

SmolAgents

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

SmolAgents

HuggingFace SmolAgents is a Python library for building AI agents. These agents write Python code to call tools and orchestrate other agents.

It uses CodeAgent. An LLM engine that writes its actions in code. SmolAgents suggests that this approach is demonstrated to work better than the current industry practice of letting the LLM output a dictionary of the tools it wants to call: uses 30% fewer steps (thus 30% fewer LLM calls) and reaches higher performance on difficult benchmarks.

Spring AI

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Spring AI

Spring AI is a Java framework that provides a Spring-friendly API and abstractions for developing AI applications.

Qdrant is available as supported vector database for use within your Spring AI projects.

Installation

You can find the Spring AI installation instructions here.

Add the Qdrant boot starter package.

<dependency>
 <groupId>org.springframework.ai</groupId>
 <artifactId>spring-ai-qdrant-store-spring-boot-starter</artifactId>
</dependency>

Usage

Configure Qdrant with Spring Boot’s application.properties.

spring.ai.vectorstore.qdrant.host=<host of your qdrant instance>
spring.ai.vectorstore.qdrant.port=<the GRPC port of your qdrant instance>
spring.ai.vectorstore.qdrant.api-key=<your api key>
spring.ai.vectorstore.qdrant.collection-name=<The name of the collection to use in Qdrant>

Learn more about these options in the configuration reference.

Stanford DSPy

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Stanford DSPy

DSPy is the framework for solving advanced tasks with language models (LMs) and retrieval models (RMs). It unifies techniques for prompting and fine-tuning LMs — and approaches for reasoning, self-improvement, and augmentation with retrieval and tools.

Provides composable and declarative modules for instructing LMs in a familiar Pythonic syntax.
Introduces an automatic compiler that teaches LMs how to conduct the declarative steps in your program.

Qdrant can be used as a retrieval mechanism in the DSPy flow.

Swiftide

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Swiftide

Swiftide is a Rust library for building LLM applications. It supports everything from simple prompt completions to fast, streaming indexing and querying pipelines, and building composable agents that use tools or call other agents.

High level features

Simple primitives for common LLM tasks
Streaming indexing and querying pipelines
Composable agents and pipelines
Modular, extendable API with minimal abstractions
Integrations with popular LLMs and storage providers
Built-in pipeline transformations (or bring your own)
Graph-like workflows with Tasks
Langfuse support

Installation

Install Swiftide with Qdrant, OpenAI, and Redis support:

Sycamore

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Sycamore

Sycamore is an LLM-powered data preparation, processing, and analytics system for complex, unstructured documents like PDFs, HTML, presentations, and more. With Aryn, you can prepare data for GenAI and RAG applications, power high-quality document processing workflows, and run analytics on large document collections with natural language.

You can use the Qdrant connector to write into and read documents from Qdrant collections.

Writing to Qdrant

To write a Docset to a Qdrant collection in Sycamore, use the docset.write.qdrant(....) function. The Qdrant writer accepts the following arguments:

Testcontainers

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Testcontainers

Testcontainers is a testing library that provides easy and lightweight APIs for bootstrapping integration tests with real services wrapped in Docker containers.

Qdrant is available as a Testcontainers module in multiple languages. It facilitates the spawning of a Qdrant instance for end-to-end testing.

Usage

import org.testcontainers.qdrant.QdrantContainer;

QdrantContainer qdrantContainer = new QdrantContainer("qdrant/qdrant");

import (
 "github.com/testcontainers/testcontainers-go"
 "github.com/testcontainers/testcontainers-go/modules/qdrant"
)

qdrantContainer, err := qdrant.RunContainer(ctx, testcontainers.WithImage("qdrant/qdrant"))

import { QdrantContainer } from "@testcontainers/qdrant";

const qdrantContainer = await new QdrantContainer("qdrant/qdrant").start();

from testcontainers.qdrant import QdrantContainer

qdrant_container = QdrantContainer("qdrant/qdrant").start()

var qdrantContainer = new QdrantBuilder()
 .WithImage("qdrant/qdrant")
 .Build();

await qdrantContainer.StartAsync();

Testcontainers modules provide options/methods to configure ENVs, volumes, and virtually everything you can configure in a Docker container.

txtai

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

txtai

Qdrant might be also used as an embedding backend in txtai semantic applications.

txtai simplifies building AI-powered semantic search applications using Transformers. It leverages the neural embeddings and their properties to encode high-dimensional data in a lower-dimensional space and allows to find similar objects based on their embeddings' proximity.

Qdrant is not built-in txtai backend and requires installing an additional dependency:

pip install qdrant-txtai

The examples and some more information might be found in qdrant-txtai repository.

Vanna.AI

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

Vanna.AI

Vanna is a Python package that uses retrieval augmentation to help you generate accurate SQL queries for your database using LLMs.

Vanna works in two easy steps - train a RAG “model” on your data, and then ask questions which will return SQL queries that can be set up to automatically run on your database.

Qdrant is available as a support vector store for ingesting and retrieving your RAG data.

VectaX - Mirror Security

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

VectaX by Mirror Security is an AI-centric access control and encryption system designed for managing and protecting vector embeddings. It combines similarity-preserving encryption with fine-grained RBAC to enable secure storage, retrieval, and operations on vector data.

It can be integrated with Qdrant to secure vector searches.

We’ll see how to do so using basic VectaX vector encryption and the sophisticated RBAC mechanism. You can obtain an API key and the Mirror SDK from the Mirror Security Platform.

VoltAgent

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jan 0001 00:00:00 +0000

VoltAgent

VoltAgent is a TypeScript-based open-source framework designed for developing AI agents that support modular tool integration, LLM coordination, and adaptable multi-agent architectures. The framework includes an integrated observability dashboard similar to n8n, enabling visual monitoring of agent operations, action tracking, and streamlined debugging capabilities.

Installation

Create a new VoltAgent project with Qdrant integration:

npm create voltagent-app@latest -- --example with-qdrant
cd with-qdrant

This command generates a fully configured project combining VoltAgent and Qdrant, including example data and two distinct agent implementation patterns.