SOLUTIONS · AGENTIC AI

Give Your Agents Memory That Works

Store, retrieve, and reason over context with vector search. Drop Qdrant into your agent's retrieval loop in under 10 minutes.

Quickstart Guide View Examples

agent_memory.py

from qdrant_client import QdrantClient
from qdrant_client.models import Filter, FieldCondition, MatchValue

# Connect to Qdrant
client = QdrantClient("localhost", port=6333)

# Agent retrieves relevant context
results = client.query_points(
    collection_name="agent_memory",
    query=embed(user_message),
    query_filter=Filter(
        must=[
            FieldCondition(
                key="session_id",
                match=MatchValue(value=session)
            )
        ]
    ),
    limit=5
)

# Feed context to LLM
context = [r.payload["text"] for r in results.points]

Trusted by

HOW IT WORKS

Three Steps to Agent Memory

No infra team required. Go from zero to production retrieval in a single session.

Store Context

Embed and upsert conversation history, documents, tool outputs, or any unstructured data your agent needs to remember.

client.upsert(collection, points)

Retrieve with Filters

Combine semantic similarity with metadata filters (session, user, timestamp, tool) to get precisely scoped context every query.

client.query_points(query, filter)

Feed to Your LLM

Inject retrieved context into your agent's prompt. Qdrant handles relevance ranking so your LLM generates grounded responses.

messages += [{"role": "system",...}]

Retrieval-Augmented Generation

Your agent queries Qdrant for semantically relevant documents, passes them as context to the LLM, and generates grounded answers instead of hallucinating. Use hybrid search (dense + sparse vectors) to catch both semantic meaning and exact terms. Add payload filters to scope retrieval by source, date, or access level.

rag_agent.py

# Hybrid search: dense + sparse
results = client.query_points(
    collection_name="knowledge_base",
    prefetch=[
        Prefetch(query=dense_vec, using="dense", limit=20),
        Prefetch(query=sparse_vec, using="sparse", limit=20),
    ],
    query=FusionQuery(
        fusion=Fusion.RRF
    ),
    limit=5
)

75%

Dust reduced RAM usage by 75% after migrating from in-memory retrieval to Qdrant for production RAG.

Real-Time Voice Agents

Voice agents can't tolerate latency. Every millisecond in the retrieval loop compounds into awkward pauses. Qdrant's Rust-based engine delivers sub-25ms P99 retrieval so your conversational agent stays responsive.

Filter by session and speaker to retrieve only the current conversation's context without cross-talk between concurrent calls.

voice_agent.py

# Low-latency session-scoped retrieval
context = client.query_points(
    collection_name="call_memory",
    query=embed(transcript_chunk),
    query_filter=Filter(
        must=[
            FieldCondition(
                key="call_id",
                match=MatchValue(
                    value=active_call
                )
            )
        ]
    ),
    limit=3
)

25ms

Tavus achieved 25ms retrieval for conversational AI without awkward pauses.

Customer Support Agents

Index your knowledge base, past tickets, and product docs. The support agent retrieves the most relevant resolution on the first pass, avoiding the loop-and-retry pattern that frustrates users. Use Qdrant's multi-tenancy (payload-based partitioning) to isolate each customer's data without deploying separate collections.

support_agent.py

# Tenant-isolated knowledge retrieval 
answer = client.query_points(
    collection_name="support_kb",
    query=embed(ticket_text),
    query_filter=Filter(
        must=[
            FieldCondition(
                key="tenant_id",
                match=MatchValue(
                    value=org_id
                )
            )
        ]
    ),
    limit=5
)

90%

Lyzr reduced latency by 90% serving support agents on Qdrant.

Recommendation Agents

Embed user behavior, product attributes, and content metadata into Qdrant. Your recommendation agent queries with the user's current context and gets semantically relevant suggestions, not just collaborative filtering. Combine dense embeddings with sparse keyword vectors for hybrid recommendations that understand both "similar style" and "exact feature match."

rec_agent.py

# Discovery: find items unlike dislikes
recs = client.discover(
    collection_name="products",
    target=user_preference_vec,
    context=[
        ContextPair(
            positive=liked_item_id,
            negative=disliked_item_id,
        )
    ],
    limit=10
)

1B+

Tripadvisor searches across billions of user-generated content pieces with Qdrant.

Multi-Agent Shared Memory

Multiple agents (planner, researcher, executor) write to and read from a shared Qdrant collection. Each agent tags its outputs with role and step metadata, so downstream agents retrieve only the context they need.

Use payload filters to scope reads by agent role, workflow step, or timestamp to prevent context pollution across agents.

multi_agent.py

# Executor reads planner's output
plan = client.query_points(
    collection_name="workflow_memory",
    query=embed(current_task),
    query_filter=Filter(
        must=[
            FieldCondition(
                key="agent_role",
                match=MatchValue(
                    value="planner"
                )
            ),
            FieldCondition(
                key="workflow_id",
                match=MatchValue(
                    value=wf_id
                )
            )
        ]
    ),
    limit=10
)

4x

Voiceflow runs managed RAG on Qdrant, powering multi-step conversational workflows at scale.

rag_agent.py

# Hybrid search: dense + sparse
results = client.query_points(
    collection_name="knowledge_base",
    prefetch=[
        Prefetch(query=dense_vec, using="dense", limit=20),
        Prefetch(query=sparse_vec, using="sparse", limit=20),
    ],
    query=FusionQuery(
        fusion=Fusion.RRF
    ),
    limit=5
)

75%

Dust reduced RAM usage by 75% after migrating from in-memory retrieval to Qdrant for production RAG.

voice_agent.py

# Low-latency session-scoped retrieval
context = client.query_points(
    collection_name="call_memory",
    query=embed(transcript_chunk),
    query_filter=Filter(
        must=[
            FieldCondition(
                key="call_id",
                match=MatchValue(
                    value=active_call
                )
            )
        ]
    ),
    limit=3
)

25ms

Tavus achieved 25ms retrieval for conversational AI without awkward pauses.

support_agent.py

# Tenant-isolated knowledge retrieval 
answer = client.query_points(
    collection_name="support_kb",
    query=embed(ticket_text),
    query_filter=Filter(
        must=[
            FieldCondition(
                key="tenant_id",
                match=MatchValue(
                    value=org_id
                )
            )
        ]
    ),
    limit=5
)

90%

Lyzr reduced latency by 90% serving support agents on Qdrant.

rec_agent.py

# Discovery: find items unlike dislikes
recs = client.discover(
    collection_name="products",
    target=user_preference_vec,
    context=[
        ContextPair(
            positive=liked_item_id,
            negative=disliked_item_id,
        )
    ],
    limit=10
)

1B+

Tripadvisor searches across billions of user-generated content pieces with Qdrant.

multi_agent.py

# Executor reads planner's output
plan = client.query_points(
    collection_name="workflow_memory",
    query=embed(current_task),
    query_filter=Filter(
        must=[
            FieldCondition(
                key="agent_role",
                match=MatchValue(
                    value="planner"
                )
            ),
            FieldCondition(
                key="workflow_id",
                match=MatchValue(
                    value=wf_id
                )
            )
        ]
    ),
    limit=10
)

4x

Voiceflow runs managed RAG on Qdrant, powering multi-step conversational workflows at scale.

Orchestration Frameworks

No-Code / Low-Code

Agent Memory

SDKs

Coding Agents

SKILL.md

# Agent Memory Skill
#
# Give your agent persistent, filtered
# memory using Qdrant as the retrieval
# backend.

# Setup
# pip install qdrant-client

# Collection Schema
# vectors:
#   dense: { size: 1536, distance: Cosine }
#   sparse: { index: { on_disk: true } }
# payload_index:
#   - session_id: keyword
#   - agent_role: keyword
#   - timestamp: integer
#   - tool_name: keyword

# Query Pattern
# Always filter by session_id + agent_role
# Use hybrid (dense+sparse) for knowledge
# Use dense-only for conversation history