chore: update qdrant to remove hybrid search breaking change (#3360)

## Summary

Describe key changes, mention related issues or motivation for the
changes.

(If applicable, issue number: #____)

## Type of change

- [ ] Bug fix
- [ ] New feature
- [ ] Breaking change
- [x] Improvement
- [ ] Model update
- [ ] Other:

---

## Checklist

- [x] Code complies with style guidelines
- [x] Ran format/validation scripts (`./scripts/format.sh` and
`./scripts/validate.sh`)
- [x] Self-review completed
- [ ] Documentation updated (comments, docstrings)
- [ ] Examples and guides: Relevant cookbook examples have been included
or updated (if applicable)
- [x] Tested in clean environment
- [ ] Tests added/updated (if applicable)

---

## Additional Notes

Add any important context (deployment instructions, screenshots,
security considerations, etc.)

Author: kausmeows

cookbook/agent_concepts/state/last_n_session_messages.py

@@ -13,8 +13,8 @@
     storage=SqliteStorage(table_name="agent_sessions_new", db_file="tmp/data.db"),
     add_history_to_messages=True,
     num_history_runs=3,
-    search_previous_sessions_history=True, # allow searching previous sessions
-    num_history_sessions=2, # only include the last 2 sessions in the search to avoid context length issues
+    search_previous_sessions_history=True,  # allow searching previous sessions
+    num_history_sessions=2,  # only include the last 2 sessions in the search to avoid context length issues
     show_tool_calls=True,
 )
 

cookbook/reasoning/teams/finance_team_chain_of_thought.py

@@ -60,9 +60,9 @@ async def run_team(task: str):
 
 
 if __name__ == "__main__":
-
-    asyncio.run(run_team(
-        dedent("""\
+    asyncio.run(
+        run_team(
+            dedent("""\
     Analyze the impact of recent US tariffs on market performance across these key sectors:
     - Steel & Aluminum: (X, NUE, AA)
     - Technology Hardware: (AAPL, DELL, HPQ)
@@ -75,4 +75,5 @@ async def run_team(task: str):
     3. Analyze companies' strategic responses (reshoring, price adjustments, supplier diversification)
     4. Assess analyst outlook changes directly attributed to tariff policies
     """)
-    ))
+        )
+    )

libs/agno/agno/vectordb/qdrant/qdrant.py

@@ -119,6 +119,10 @@ def __init__(
         self.sparse_vector_name = sparse_vector_name
         self.hybrid_fusion_strategy = hybrid_fusion_strategy
 
+        # TODO(v2.0.0): Remove backward compatibility for unnamed vectors
+        # TODO(v2.0.0): Make named vectors mandatory and simplify the codebase
+        self.use_named_vectors = search_type in [SearchType.hybrid]
+
         if self.search_type in [SearchType.keyword, SearchType.hybrid]:
             try:
                 from fastembed import SparseTextEmbedding
@@ -131,7 +135,7 @@ def __init__(
 
             except ImportError as e:
                 raise ImportError(
-                    "To use keyword/hybrid search, install the `fastembed` extra with `pip install 'qdrant-client[fastembed]'`."
+                    "To use keyword/hybrid search, install the `fastembed` extra with `pip install fastembed`."
                 ) from e
 
     @property
@@ -176,7 +180,6 @@ def async_client(self) -> AsyncQdrantClient:
         return self._async_client
 
     def create(self) -> None:
-        # Collection distance
         _distance = models.Distance.COSINE
         if self.distance == Distance.l2:
             _distance = models.Distance.EUCLID
@@ -185,11 +188,18 @@ def create(self) -> None:
 
         if not self.exists():
             log_debug(f"Creating collection: {self.collection}")
+
+            # Configure vectors based on search type
+            if self.search_type == SearchType.vector:
+                # Maintain backward compatibility with unnamed vectors
+                vectors_config = models.VectorParams(size=self.dimensions, distance=_distance)
+            else:
+                # Use named vectors for hybrid search
+                vectors_config = {self.dense_vector_name: models.VectorParams(size=self.dimensions, distance=_distance)}
+
             self.client.create_collection(
                 collection_name=self.collection,
-                vectors_config={self.dense_vector_name: models.VectorParams(size=self.dimensions, distance=_distance)}
-                if self.search_type in [SearchType.vector, SearchType.hybrid]
-                else {},
+                vectors_config=vectors_config,
                 sparse_vectors_config={self.sparse_vector_name: models.SparseVectorParams()}
                 if self.search_type in [SearchType.keyword, SearchType.hybrid]
                 else None,
@@ -206,11 +216,18 @@ async def async_create(self) -> None:
 
         if not await self.async_exists():
             log_debug(f"Creating collection asynchronously: {self.collection}")
+
+            # Configure vectors based on search type
+            if self.search_type == SearchType.vector:
+                # Maintain backward compatibility with unnamed vectors
+                vectors_config = models.VectorParams(size=self.dimensions, distance=_distance)
+            else:
+                # Use named vectors for hybrid search
+                vectors_config = {self.dense_vector_name: models.VectorParams(size=self.dimensions, distance=_distance)}
+
             await self.async_client.create_collection(
                 collection_name=self.collection,
-                vectors_config={self.dense_vector_name: models.VectorParams(size=self.dimensions, distance=_distance)}
-                if self.search_type in [SearchType.vector, SearchType.hybrid]
-                else {},
+                vectors_config=vectors_config,
                 sparse_vectors_config={self.sparse_vector_name: models.SparseVectorParams()}
                 if self.search_type in [SearchType.keyword, SearchType.hybrid]
                 else None,
@@ -300,13 +317,25 @@ def insert(self, documents: List[Document], filters: Optional[Dict[str, Any]] =
             cleaned_content = document.content.replace("\x00", "\ufffd")
             doc_id = md5(cleaned_content.encode()).hexdigest()
 
-            vector = {}
-            if self.search_type in [SearchType.vector, SearchType.hybrid]:
+            # TODO(v2.0.0): Remove conditional vector naming logic
+            if self.use_named_vectors:
+                vector = {self.dense_vector_name: document.embedding}
+            else:
+                vector = document.embedding  # type: ignore
+
+            if self.search_type == SearchType.vector:
+                # For vector search, maintain backward compatibility with unnamed vectors
                 document.embed(embedder=self.embedder)
-                vector[self.dense_vector_name] = document.embedding
+                vector = document.embedding  # type: ignore
+            else:
+                # For other search types, use named vectors
+                vector = {}
+                if self.search_type in [SearchType.hybrid]:
+                    document.embed(embedder=self.embedder)
+                    vector[self.dense_vector_name] = document.embedding
 
-            if self.search_type in [SearchType.keyword, SearchType.hybrid]:
-                vector[self.sparse_vector_name] = next(self.sparse_encoder.embed([document.content])).as_object()
+                if self.search_type in [SearchType.keyword, SearchType.hybrid]:
+                    vector[self.sparse_vector_name] = next(self.sparse_encoder.embed([document.content])).as_object()
 
             # Create payload with document properties
             payload = {
@@ -349,11 +378,19 @@ async def process_document(document):
             cleaned_content = document.content.replace("\x00", "\ufffd")
             doc_id = md5(cleaned_content.encode()).hexdigest()
 
-            vector = {}
-
-            if self.search_type in [SearchType.vector, SearchType.hybrid]:
+            if self.search_type == SearchType.vector:
+                # For vector search, maintain backward compatibility with unnamed vectors
                 document.embed(embedder=self.embedder)
-                vector[self.dense_vector_name] = document.embedding
+                vector = document.embedding
+            else:
+                # For other search types, use named vectors
+                vector = {}
+                if self.search_type in [SearchType.hybrid]:
+                    document.embed(embedder=self.embedder)
+                    vector[self.dense_vector_name] = document.embedding
+
+                if self.search_type in [SearchType.keyword, SearchType.hybrid]:
+                    vector[self.sparse_vector_name] = next(self.sparse_encoder.embed([document.content])).as_object()
 
             if self.search_type in [SearchType.keyword, SearchType.hybrid]:
                 vector[self.sparse_vector_name] = next(self.sparse_encoder.embed([document.content])).as_object()
@@ -441,64 +478,77 @@ async def async_search(
 
         return self._build_search_results(results, query)
 
-    def _run_vector_search_sync(
+    def _run_hybrid_search_sync(
         self,
         query: str,
         limit: int,
         filters: Optional[Dict[str, Any]],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
+        sparse_embedding = next(self.sparse_encoder.embed([query])).as_object()
         call = self.client.query_points(
             collection_name=self.collection,
-            query=dense_embedding,
+            prefetch=[
+                models.Prefetch(
+                    query=models.SparseVector(**sparse_embedding),
+                    limit=limit,
+                    using=self.sparse_vector_name,
+                ),
+                models.Prefetch(query=dense_embedding, limit=limit, using=self.dense_vector_name),
+            ],
+            query=models.FusionQuery(fusion=self.hybrid_fusion_strategy),
             with_vectors=True,
             with_payload=True,
             limit=limit,
             query_filter=filters,
-            using=self.dense_vector_name,
         )
         return call.points
 
-    def _run_keyword_search_sync(
+    def _run_vector_search_sync(
         self,
         query: str,
         limit: int,
         filters: Optional[Dict[str, Any]],
     ) -> List[models.ScoredPoint]:
-        sparse_embedding = next(self.sparse_encoder.embed([query])).as_object()
-        call = self.client.query_points(
-            collection_name=self.collection,
-            query=models.SparseVector(**sparse_embedding),
-            with_vectors=True,
-            with_payload=True,
-            limit=limit,
-            using=self.sparse_vector_name,
-            query_filter=filters,
-        )
+        dense_embedding = self.embedder.get_embedding(query)
+
+        # TODO(v2.0.0): Remove this conditional and always use named vectors
+        if self.use_named_vectors:
+            call = self.client.query_points(
+                collection_name=self.collection,
+                query=dense_embedding,
+                with_vectors=True,
+                with_payload=True,
+                limit=limit,
+                query_filter=filters,
+                using=self.dense_vector_name,
+            )
+        else:
+            # Backward compatibility mode - use unnamed vector
+            call = self.client.query_points(
+                collection_name=self.collection,
+                query=dense_embedding,
+                with_vectors=True,
+                with_payload=True,
+                limit=limit,
+                query_filter=filters,
+            )
         return call.points
 
-    def _run_hybrid_search_sync(
+    def _run_keyword_search_sync(
         self,
         query: str,
         limit: int,
         filters: Optional[Dict[str, Any]],
     ) -> List[models.ScoredPoint]:
-        dense_embedding = self.embedder.get_embedding(query)
         sparse_embedding = next(self.sparse_encoder.embed([query])).as_object()
         call = self.client.query_points(
             collection_name=self.collection,
-            prefetch=[
-                models.Prefetch(
-                    query=models.SparseVector(**sparse_embedding),
-                    limit=limit,
-                    using=self.sparse_vector_name,
-                ),
-                models.Prefetch(query=dense_embedding, limit=limit, using=self.dense_vector_name),
-            ],
-            query=models.FusionQuery(fusion=self.hybrid_fusion_strategy),
+            query=models.SparseVector(**sparse_embedding),
             with_vectors=True,
             with_payload=True,
             limit=limit,
+            using=self.sparse_vector_name,
             query_filter=filters,
         )
         return call.points
@@ -510,15 +560,28 @@ async def _run_vector_search_async(
         filters: Optional[Dict[str, Any]],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
-        call = await self.async_client.query_points(
-            collection_name=self.collection,
-            query=dense_embedding,
-            with_vectors=True,
-            with_payload=True,
-            limit=limit,
-            query_filter=filters,
-            using=self.dense_vector_name,
-        )
+
+        # TODO(v2.0.0): Remove this conditional and always use named vectors
+        if self.use_named_vectors:
+            call = await self.async_client.query_points(
+                collection_name=self.collection,
+                query=dense_embedding,
+                with_vectors=True,
+                with_payload=True,
+                limit=limit,
+                query_filter=filters,
+                using=self.dense_vector_name,
+            )
+        else:
+            # Backward compatibility mode - use unnamed vector
+            call = await self.async_client.query_points(
+                collection_name=self.collection,
+                query=dense_embedding,
+                with_vectors=True,
+                with_payload=True,
+                limit=limit,
+                query_filter=filters,
+            )
         return call.points
 
     async def _run_keyword_search_async(

libs/agno/pyproject.toml

@@ -315,6 +315,7 @@ module = [
   "e2b_code_interpreter.*",
   "exa_py.*",
   "fastapi.*",
+  "fastembed.*",
   "filetype.*",
   "firecrawl.*",
   "github.*",