Update AI agents page

qdrant-landing/content/ai-agents/ai-agents-builder-patterns.md

@@ -0,0 +1,120 @@
+---
+subtitle: BUILDER PATTERNS
+title: What Developers Build with Qdrant
+description: Common agent architectures and the retrieval patterns behind them.
+features:
+  - id: 0
+    title: Retrieval-Augmented Generation
+    description: 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.
+    codeBar: rag_agent.py
+    code: |
+      # 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
+      )
+    cardTitle: 75%
+    cardContent: <b>Dust</b> reduced RAM usage by 75% after migrating from in-memory retrieval to Qdrant for production RAG.
+  - id: 1
+    title: Real-Time Voice Agents
+    description: 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.<br><br>Filter by session and speaker to retrieve only the current conversation's context without cross-talk between concurrent calls.
+    codeBar: voice_agent.py
+    code: |
+      # 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
+      )
+    cardTitle: 25ms
+    cardContent: <b>Tavus</b> achieved 25ms retrieval for conversational AI without awkward pauses.
+  - id: 2
+    title: Customer Support Agents
+    description: 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.
+    codeBar: support_agent.py
+    code: |
+      # 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
+      )
+    cardTitle: 90%
+    cardContent: <b>Lyzr</b> reduced latency by 90% serving support agents on Qdrant.
+  - id: 3
+    title: Recommendation Agents
+    description: 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."
+    codeBar: rec_agent.py
+    code: |
+      # 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
+      )
+    cardTitle: 1B+
+    cardContent: <b>Tripadvisor</b> searches across billions of user-generated content pieces with Qdrant.
+  - id: 4
+    title: Multi-Agent Shared Memory
+    description: 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.<br><br>Use payload filters to scope reads by agent role, workflow step, or timestamp to prevent context pollution across agents.
+    codeBar: multi_agent.py
+    code: |
+      # 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
+      )
+    cardTitle: 4x
+    cardContent: <b>Voiceflow</b> runs managed RAG on Qdrant, powering multi-step conversational workflows at scale.
+sitemapExclude: true
+---

qdrant-landing/content/ai-agents/ai-agents-cta-banner.md

@@ -0,0 +1,12 @@
+---
+type: cta-banner
+title: Your Agents Deserve Better Retrieval
+description: Start with the free tier. Scale to billions of vectors when you're ready.
+button:
+  text: Start Building Free
+  url: https://cloud.qdrant.io/signup # add params?
+secondaryButton:
+  text: Talk to an Engineer
+  url: /contact-us/
+sitemapExclude: true
+---

qdrant-landing/content/ai-agents/ai-agents-features.md

@@ -1,62 +1,60 @@
 ---
-image: 
-  src: /img/ai-agents-dashboard-cloud.png
-  alt: Dashboard cloud
-title: AI Agents with Qdrant
-description: AI agents powered by Qdrant leverage advanced vector search to access and retrieve high-dimensional data in real-time, enabling intelligent, Agentic-RAG driven, multi-step decision-making across dynamic environments.
-cases:
-- id: 0
-  title: Multimodal Data Handling
-  description: Qdrant enables AI agents to process and retrieve high-dimensional vectors from diverse data types (text, images, audio), supporting more comprehensive decision-making in multimodal environments.
-- id: 1
-  title: Adaptive Learning
-  description: Qdrant supports continuous learning by enabling efficient vector retrieval and updates, allowing agents to learn and evolve based on real-time interactions and new data points.
-featuresTitle: Qdrant equips AI agents to adapt, learn, and collaborate efficiently.
+subtitle: DEVELOPER TOOLS
+title: Purpose-Built for Agent Builders
+description: Tools and patterns that make agent memory a solved problem, not a research project.
+button:
+  text: Start Building with Skills
+  url: https://github.com/qdrant/skills
+codeBar: SKILL.md
+code: |
+  # 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
 features:
-- id: 0
-  icon: 
-    src: /icons/outline/precision-blue.svg
-    alt: Precision
-  title: Contextual Precision
-  description: Qdrant’s hybrid search combines semantic vector search, lexical search, and metadata filtering, enabling AI Agents to retrieve highly relevant and contextually precise information. This enhances decision-making by allowing agents to leverage both meaning-based and keyword-based strategies, ensuring accuracy and relevance for complex queries in dynamic environments.
-  link:
-    text: Hybrid Search
-    url: /articles/hybrid-search/
-- id: 1
-  icon:
-    src: /icons/outline/multitenancy-blue.svg
-    alt: Multitenancy
-  title: Multi-Agent Systems
-  description: Qdrant’s scalability and multitenancy ensures that multiple agents can collaborate in distributed systems, enabling seamless coordination and communication - key for Agentic RAG workflows.
-  link:
-    text: Multitenancy
-    url: /articles/multitenancy/
-- id: 2
-  icon:
-    src: /icons/outline/time-blue.svg
-    alt: Time
-  title: Real Time Decision Making
-  description: Qdrant’s real-time, advanced vector search enables AI agents to act instantly on live data, which is crucial for time-sensitive, autonomous decision-making.
-  link:
-    text: HNSW
-    url: /articles/filterable-hnsw/
-- id: 3
-  icon:
-    src: /icons/outline/server-rack-blue.svg
-    alt: Server rack
-  title: Optimized CPU Performance for Embedding Processing
-  description: Qdrant’s architecture is optimized for high-throughput embedding processing, minimizing CPU load and preventing performance bottlenecks. This enables AI agents in Agentic RAG workflows to execute complex, multi-step tasks efficiently, ensuring smooth operation even at scale.
-  link:
-    text: Distributed Deployment
-    url: /documentation/distributed_deployment/
-- id: 4
-  icon:
-    src: /icons/outline/speedometer-blue.svg
-    alt: Speedometer
-  title: Semantic Cache for Rapid Query Handling
-  description: Qdrant enhances AI agent efficiency with semantic caching, which preserves results of queries based on semantic equivalence rather than exact matches. This method reduces query processing times and system load by reusing previously computed answers, essential for high-throughput AI applications.
-  link:
-    text: Semantic Cache
-    url: /articles/semantic-cache-ai-data-retrieval/
+  - id: 0
+    icon:
+      src: /icons/outline/text-search-pink.svg
+      alt: Text search
+    content: <b>Hybrid search</b> combines dense embeddings with BM25 sparse vectors via reciprocal rank fusion
+  - id: 1
+    icon:
+      src: /icons/outline/filter-blue-large.svg
+      alt: Filter
+    content: <b>Payload filtering</b> scopes retrieval by any metadata field without post-processing
+  - id: 2
+    icon:
+      src: /icons/outline/boxes-purple.svg
+      alt: Boxes
+    content: <b>Multi-vector support</b> stores ColBERT token-level representations natively
+  - id: 3
+    icon:
+      src: /icons/outline/target-green.svg
+      alt: Target
+    content: <b>Quantization</b> (scalar, binary, product) cuts memory 4x while preserving accuracy
+  - id: 4
+    icon:
+      src: /icons/outline/git-branch-orange.svg
+      alt: Git branch
+    content: <b>Real-time upserts</b> let agents write new memories without index rebuild delays
 sitemapExclude: true
 ---

qdrant-landing/content/ai-agents/ai-agents-hero.md

@@ -1,14 +1,51 @@
 ---
-title: AI Agents
-description: Unlock the full potential of your AI agents with Qdrant’s powerful vector search and scalable infrastructure, allowing them to handle complex tasks, adapt in real time, and drive smarter, data-driven outcomes across any environment.
-startFree:
-  text: Get Started
-  url: https://cloud.qdrant.io/signup
-learnMore:
-  text: Learn More
-  url: "#ai-agents"
-image:
-  src: /img/vectors/vector-4.svg
-  alt: AI agents chat
+subtitle: SOLUTIONS · AGENTIC AI
+title: Give Your Agents Memory That Works
+description: Store, retrieve, and reason over context with vector search. Drop Qdrant into your agent's retrieval loop in under 10 minutes.
+containedButton:
+  text: Quickstart Guide
+  url: /documentation/quickstart/
+outlinedButton:
+  text: View Examples
+  url: /blog/qdrant-skills-release/
+codeBar: agent_memory.py
+code: |
+  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]
+logosTitle: Trusted by
+logos: 
+  - id: 0
+    src: /img/ai-agents-logos/lyzr.svg
+    alt: Lyzr logo
+  - id: 1
+    src: /img/ai-agents-logos/dust.svg
+    alt: Dust logo
+  - id: 2
+    src: /img/ai-agents-logos/voiceflow.svg
+    alt: Voiceflow logo
+  - id: 3
+    src: /img/ai-agents-logos/trustgraph.svg
+    alt: TrustGraph logo
 sitemapExclude: true
 ---

qdrant-landing/content/ai-agents/ai-agents-how-it-works.md

@@ -0,0 +1,25 @@
+---
+subtitle: HOW IT WORKS
+title: Three Steps to Agent Memory
+description: No infra team required. Go from zero to production retrieval in a single session.
+steps:
+  - id: 0
+    title: Store Context
+    description: Embed and upsert conversation history, documents, tool outputs, or any unstructured data your agent needs to remember.
+    code: |
+      client.upsert(collection, points)
+  - id: 1
+    title: Retrieve with Filters
+    description: Combine semantic similarity with metadata filters (session, user, timestamp, tool) to get precisely scoped context every query.
+    code: |
+      client.query_points(query, filter)
+  - id: 2
+    title: Feed to Your LLM
+    description: Inject retrieved context into your agent's prompt. Qdrant handles relevance ranking so your LLM generates grounded responses.
+    code: |
+      messages += [{"role": "system",...}]
+image:
+  src: /img/ai-agents-memory.svg
+  alt: Vector Search for Agent Memory
+sitemapExclude: true
+---