Vector store integrations

.NET vector store support

Agent Framework uses the .NET AI ecosystem's standalone abstractions:

• Microsoft.Extensions.VectorData provides common vector store, collection, record, and search APIs.
• Microsoft.Extensions.AI provides abstractions such as IEmbeddingGenerator for generating embeddings independently of a specific model provider.

Where an Agent Framework component accepts a vector store, you can supply a compatible Microsoft.Extensions.VectorData implementation. Each database implementation is distributed separately from the abstractions package.

Core abstractions

Available vector store implementations

The following implementations use the common .NET vector store abstractions. Review each implementation's documentation for package versions, supported data types, and service-specific limitations.

Get started

1. Add the Microsoft.Extensions.VectorData.Abstractions package and the package for your chosen vector store implementation.
2. Define a record type and identify its key, data, and vector properties.
3. Configure an IEmbeddingGenerator if your implementation requires application-generated embeddings.
4. Create the implementation's VectorStore, and then get a typed VectorStoreCollection<TKey, TRecord>.
5. Ensure that the collection exists, upsert records, and call SearchAsync with text or a vector.

For a complete introduction to data models, ingestion, embeddings, and search, see Vector databases for .NET AI apps.

Python vector store support

Agent Framework provides experimental, native Python contracts for vector store models, collection operations, store factories, vector and keyword-hybrid search, and agent search tools. The contracts are part of agent-framework-core and don't require Pydantic, NumPy, pandas, or Semantic Kernel.

Core abstractions

The following sample defines vector store records by annotating their key, data, and vector fields:

# 5. Dataclasses use the default registered codec.
@vectorstoremodel(collection_name="hotels")
@dataclass
class Hotel:
    hotel_id: Annotated[str, VectorStoreField("key")]
    name: Annotated[str, VectorStoreField("data", is_indexed=True)]
    description: Annotated[
        str | list[float] | None,
        VectorStoreField("vector", dimensions=3, distance_function="cosine_similarity"),
    ] = None


# 6. Pydantic models provide validation with additional round-trip cost.
@vectorstoremodel(collection_name="products")
class Product(BaseModel):
    product_id: Annotated[str, VectorStoreField("key")]
    name: Annotated[str, VectorStoreField("data", is_full_text_indexed=True)]
    vector: Annotated[list[float] | None, VectorStoreField("vector", dimensions=3)] = None

Use VectorStoreCollectionDefinition directly for dictionaries. For model types owned by another package, use register_vectorstoremodel() with an explicit definition and optional encoder and decoder. Array-like vector values serialize through tolist() without adding a NumPy dependency.

Agent Framework includes an in-memory implementation for development and tests. It stores records in the current process and uses a linear scan, so use a database connector for production workloads.

The following sample stores precomputed vectors and searches them with a portable filter tree:

import asyncio
from dataclasses import dataclass
from typing import Annotated

from agent_framework import Filter, FilterGroup, InMemoryCollection, VectorStoreField, vectorstoremodel
@vectorstoremodel(collection_name="hotels")
@dataclass
class Hotel:
    hotel_id: Annotated[str, VectorStoreField("key")]
    name: Annotated[str, VectorStoreField("data")]
    city: Annotated[str, VectorStoreField("data")]
    rating: Annotated[float, VectorStoreField("data")]
    amenities: Annotated[list[str], VectorStoreField("data")]
    vector: Annotated[
        list[float] | None,
        VectorStoreField("vector", dimensions=2, distance_function="cosine_similarity"),
    ] = None


async def main() -> None:
    """Store precomputed vectors and search them with direct filters."""
    collection: InMemoryCollection[str, Hotel] = InMemoryCollection(Hotel)
    await collection.ensure_collection_exists()

    # 1. The sample already has vectors, so generation is disabled explicitly.
    await collection.upsert(
        [
            Hotel("hotel-1", "Harbor View", "Lisbon", 4.8, ["wifi", "pool"], [1.0, 0.1]),
            Hotel("hotel-2", "Old Town Rooms", "Lisbon", 4.1, ["wifi"], [0.8, 0.2]),
            Hotel("hotel-3", "City Center", "Seattle", 4.7, ["wifi", "gym"], [0.1, 1.0]),
        ],
        generate_vectors=False,
    )

    # 2. Filter values are ordinary data. No Python source is parsed or executed.
    search_filter = FilterGroup(
        "and",
        (
            Filter("city", "eq", "Lisbon"),
            Filter("rating", "between", (4.5, 5.0)),
            Filter("amenities", "contains", "pool"),
        ),
    )
    results = await collection.search(
        vector=[1.0, 0.0],
        filter=search_filter,
        top=5,
    )

    # 3. Search results are consumed asynchronously.
    async for result in results:
        print(f"{result['record'].name}: {result['score']:.3f}")

Use Param when the model should supply a filter value. Its Python type, description, and constraints become part of the search tool's JSON schema:

# 2. Param values become optional model-visible filter arguments.
# When the allowed values are known, use Literal so the tool schema exposes
# them as an enum.
category = Param(
    "category",
    Literal["Boutique", "Budget", "Extended-Stay", "Luxury", "Resort and Spa", "Suite"],
    description="Only return hotels in this category.",
)
min_rating = Param(
    "min_rating",
    float,
    description="The minimum guest rating.",
    minimum=0,
    maximum=5,
)
tool = create_vector_search_tool(
    collection,
    description="Search the hotel dataset, optionally filtering by category and minimum rating.",
    filter=FilterGroup(
        "and",
        (
            Filter("category", "eq", category),
            Filter("rating", "gte", min_rating),
        ),
    ),
    result_mapper=lambda result: (
        f"(hotel_id: {result['record'].hotel_id}) {result['record'].hotel_name} "
        f"(rating {result['record'].rating}) - {result['record'].description}. "
        f"Address: {result['record'].address.city}, {result['record'].address.country}."
    ),
)

Native Agent Framework implementations

The following implementations use the native Agent Framework contracts. Each one is also available as a separate Semantic Kernel connector, but the two connector families aren't interchangeable.

Install a prerelease connector package for the database you use:

pip install agent-framework-azure-ai-search --pre
pip install agent-framework-postgres --pre
pip install agent-framework-qdrant --pre
pip install agent-framework-redis --pre

Each connector implements the common model, collection, CRUD, filter, and search contracts. Database-specific capabilities and restrictions still apply. For complete examples, see the Azure AI Search, Postgres, Qdrant, and Redis samples.

Semantic Kernel-only implementations

Applications can continue to use Semantic Kernel's Python vector stores directly. These implementations use the separate Semantic Kernel vector store contracts rather than the native Agent Framework contracts. The following implementations don't currently have a native Agent Framework connector:

Use a Semantic Kernel-only implementation

1. Install semantic-kernel and the dependencies required by your chosen implementation.
2. Define a model with the @vectorstoremodel decorator and identify its key, data, and vector fields.
3. Create an implementation-specific collection for that model.
4. Ensure that the collection exists, and then upsert records.
5. Use the collection's search APIs to retrieve records for your application.

For implementation setup and complete examples, see Semantic Kernel Vector Stores.

Go vector store support

Vector store integration isn't yet available in Agent Framework for Go. See the Agent Framework Go repository for the latest status.