EF Core 10: Vector Search, LeftJoin/RightJoin, and Full-Text Search on Cosmos DB

Entity Framework Core 10, released alongside .NET 10, introduces features that position it as a first-class choice for AI-powered applications. The headline addition—vector search support—enables semantic similarity queries directly in LINQ, while new LeftJoin/RightJoin operators and Cosmos DB full-text search round out a release focused on modern data access patterns. This comprehensive guide explores each feature with production-ready implementations, performance considerations, and migration strategies.

What’s New in EF Core 10

Vector Search: AI-Native Data Access

Vector search enables finding semantically similar records based on embedding vectors—the foundation of RAG (Retrieval Augmented Generation) applications. EF Core 10 brings this capability directly into LINQ.

Architecture Overview

graph LR
    subgraph Application ["Application Layer"]
        Query["User Query"]
        EF["EF Core 10"]
    end
    
    subgraph Embedding ["Embedding Service"]
        OpenAI["Azure OpenAI"]
        Vector["Query Vector"]
    end
    
    subgraph Database ["Database Layer"]
        VectorIndex["Vector Index"]
        Results["Similar Documents"]
    end
    
    Query --> OpenAI
    OpenAI --> Vector
    Vector --> EF
    EF --> VectorIndex
    VectorIndex --> Results
    Results --> EF
    
    style EF fill:#E8F5E9,stroke:#2E7D32
    style VectorIndex fill:#E3F2FD,stroke:#1565C0

Configuring Vector Columns

First, define your entity with an embedding vector property:

public class Document
{
    public int Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string Content { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
    
    // Vector embedding - typically 1536 dimensions for text-embedding-3-small
    public float[] ContentEmbedding { get; set; } = Array.Empty<float>();
}

public class AppDbContext : DbContext
{
    public DbSet<Document> Documents => Set<Document>();
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Document>(entity =>
        {
            // Configure the vector column with dimensions and index type
            entity.Property(e => e.ContentEmbedding)
                .HasColumnType("vector(1536)")  // SQL Server / PostgreSQL
                .HasVectorIndex(VectorIndexType.Hnsw);  // HNSW for fast approximate search
            
            // Alternative: IVFFlat for faster inserts, slightly slower queries
            // .HasVectorIndex(VectorIndexType.IvfFlat, lists: 100);
        });
    }
}

Performing Vector Similarity Queries

public class DocumentSearchService
{
    private readonly AppDbContext _context;
    private readonly IEmbeddingGenerator _embeddings;
    
    public DocumentSearchService(AppDbContext context, IEmbeddingGenerator embeddings)
    {
        _context = context;
        _embeddings = embeddings;
    }
    
    public async Task<List<DocumentSearchResult>> SemanticSearchAsync(
        string query, 
        int topK = 10,
        float minSimilarity = 0.7f)
    {
        // Generate embedding for the search query
        var queryEmbedding = await _embeddings.GenerateEmbeddingAsync(query);
        
        // Perform vector similarity search using LINQ
        var results = await _context.Documents
            .Select(d => new
            {
                Document = d,
                // EF.Functions.VectorDistance computes cosine distance
                Similarity = 1 - EF.Functions.VectorDistance(
                    d.ContentEmbedding, 
                    queryEmbedding,
                    DistanceFunction.Cosine)
            })
            .Where(x => x.Similarity >= minSimilarity)
            .OrderByDescending(x => x.Similarity)
            .Take(topK)
            .Select(x => new DocumentSearchResult
            {
                Id = x.Document.Id,
                Title = x.Document.Title,
                Content = x.Document.Content,
                Similarity = x.Similarity
            })
            .ToListAsync();
        
        return results;
    }
}

public record DocumentSearchResult
{
    public int Id { get; init; }
    public string Title { get; init; } = string.Empty;
    public string Content { get; init; } = string.Empty;
    public float Similarity { get; init; }
}

Hybrid Search: Combining Vector and Keyword

For production RAG applications, hybrid search combines vector similarity with keyword matching:

public async Task<List<DocumentSearchResult>> HybridSearchAsync(
    string query,
    int topK = 10)
{
    var queryEmbedding = await _embeddings.GenerateEmbeddingAsync(query);
    var keywords = ExtractKeywords(query);
    
    var results = await _context.Documents
        .Select(d => new
        {
            Document = d,
            VectorScore = 1 - EF.Functions.VectorDistance(
                d.ContentEmbedding, queryEmbedding, DistanceFunction.Cosine),
            // Full-text search score (provider-specific)
            KeywordScore = EF.Functions.FreeText(d.Content, string.Join(" ", keywords)) 
                ? 1.0f : 0.0f
        })
        .Select(x => new
        {
            x.Document,
            // Reciprocal Rank Fusion combining both scores
            HybridScore = (0.7f * x.VectorScore) + (0.3f * x.KeywordScore)
        })
        .OrderByDescending(x => x.HybridScore)
        .Take(topK)
        .Select(x => new DocumentSearchResult
        {
            Id = x.Document.Id,
            Title = x.Document.Title,
            Content = x.Document.Content,
            Similarity = x.HybridScore
        })
        .ToListAsync();
    
    return results;
}

LeftJoin and RightJoin Operators

EF Core has long required workarounds for outer joins using GroupJoin with DefaultIfEmpty. EF Core 10 introduces first-class LeftJoin and RightJoin operators:

Before EF Core 10

// The old, verbose way to do a left join
var ordersWithCustomers = await context.Orders
    .GroupJoin(
        context.Customers,
        order => order.CustomerId,
        customer => customer.Id,
        (order, customers) => new { order, customers })
    .SelectMany(
        x => x.customers.DefaultIfEmpty(),
        (x, customer) => new
        {
            OrderId = x.order.Id,
            OrderDate = x.order.OrderDate,
            CustomerName = customer != null ? customer.Name : "No Customer"
        })
    .ToListAsync();

EF Core 10 LeftJoin

// Clean, readable left join
var ordersWithCustomers = await context.Orders
    .LeftJoin(
        context.Customers,
        order => order.CustomerId,
        customer => customer.Id,
        (order, customer) => new
        {
            OrderId = order.Id,
            OrderDate = order.OrderDate,
            CustomerName = customer != null ? customer.Name : "No Customer"
        })
    .ToListAsync();

// Right join works the same way
var customersWithOrders = await context.Customers
    .RightJoin(
        context.Orders,
        customer => customer.Id,
        order => order.CustomerId,
        (customer, order) => new
        {
            OrderId = order.Id,
            CustomerName = customer?.Name ?? "Unknown"
        })
    .ToListAsync();

Multiple Join Conditions

// Composite key join
var results = await context.Orders
    .LeftJoin(
        context.Shipments,
        order => new { order.Id, order.WarehouseId },
        shipment => new { Id = shipment.OrderId, shipment.WarehouseId },
        (order, shipment) => new
        {
            order.Id,
            order.Total,
            ShipmentStatus = shipment != null ? shipment.Status : "Not Shipped",
            TrackingNumber = shipment?.TrackingNumber
        })
    .ToListAsync();

Cosmos DB Full-Text and Hybrid Search

For Cosmos DB users, EF Core 10 adds native support for full-text search using BM25 ranking and hybrid search combining text and vector:

public class CosmosDocumentSearchService
{
    private readonly CosmosDbContext _context;
    
    public async Task<List<Document>> FullTextSearchAsync(string searchText)
    {
        // Full-text search with BM25 ranking
        return await _context.Documents
            .Where(d => EF.Functions.FullTextContains(d.Content, searchText))
            .OrderByDescending(d => EF.Functions.FullTextScore(d.Content, searchText))
            .Take(20)
            .ToListAsync();
    }
    
    public async Task<List<DocumentSearchResult>> HybridSearchCosmosAsync(
        string query,
        float[] queryEmbedding)
    {
        // Hybrid search: combines vector similarity with full-text BM25
        return await _context.Documents
            .Select(d => new
            {
                Document = d,
                VectorScore = EF.Functions.VectorDistance(
                    d.ContentEmbedding, queryEmbedding, DistanceFunction.Cosine),
                TextScore = EF.Functions.FullTextScore(d.Content, query)
            })
            .OrderBy(x => EF.Functions.Rrf(x.VectorScore, x.TextScore))  // Reciprocal Rank Fusion
            .Take(10)
            .Select(x => new DocumentSearchResult
            {
                Id = x.Document.Id,
                Title = x.Document.Title,
                Content = x.Document.Content
            })
            .ToListAsync();
    }
}

ExecuteUpdateAsync with Non-Expression Lambdas

EF Core 7 introduced ExecuteUpdateAsync for bulk updates, but required expression lambdas. EF Core 10 allows regular lambdas for more flexible update logic:

// Before EF Core 10: Expression lambda only
await context.Products
    .Where(p => p.Category == "Electronics")
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(p => p.Price, p => p.Price * 1.1m));  // Must be expression

// EF Core 10: Regular lambda with complex logic
var discountRules = await LoadDiscountRulesAsync();

await context.Products
    .Where(p => p.Category == "Electronics")
    .ExecuteUpdateAsync(setters =>
    {
        // Complex logic with external data
        var rule = discountRules.FirstOrDefault(r => r.IsActive);
        var multiplier = rule?.Multiplier ?? 1.0m;
        
        return setters
            .SetProperty(p => p.Price, p => p.Price * multiplier)
            .SetProperty(p => p.LastUpdated, DateTime.UtcNow)
            .SetProperty(p => p.UpdatedBy, GetCurrentUserId());
    });

Performance Benchmarks

Our benchmarks on Azure SQL Database with 1M documents show:

Migration from EF Core 9

<!-- Update package references -->
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="10.0.0" />
<!-- Or for PostgreSQL with pgvector -->
<PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.0" />
<!-- Or for Cosmos DB -->
<PackageReference Include="Microsoft.EntityFrameworkCore.Cosmos" Version="10.0.0" />

Breaking Changes to Watch

• EF.Functions.Like now uses database collation by default (was case-sensitive)
• DbContext.Database.EnsureCreated() creates vector indexes automatically
• JSON column mapping now uses System.Text.Json source generators for AOT compatibility

Key Takeaways

• Vector search in EF Core 10 enables semantic similarity queries directly in LINQ, making RAG applications straightforward to build.
• LeftJoin/RightJoin operators eliminate the verbose GroupJoin+DefaultIfEmpty pattern, improving code readability.
• Cosmos DB full-text search with hybrid vector support positions Cosmos DB as a viable single-database RAG backend.
• Non-expression lambdas in ExecuteUpdateAsync enable more flexible bulk update logic with external data.
• Performance improvements across query translation and execution benefit all EF Core applications.

Conclusion

EF Core 10 represents a strategic investment in AI-ready data access. Vector search support removes the need for specialized vector databases in many scenarios, while quality-of-life improvements like LeftJoin operators make everyday queries cleaner. For teams building AI-powered applications on .NET 10, EF Core 10 provides a unified, familiar API for both traditional relational queries and semantic search—reducing architectural complexity and accelerating development.

References

• What’s New in EF Core 10 – Microsoft Docs
• Announcing EF Core 10 – .NET Blog
• Azure Cosmos DB Vector Search
• Npgsql EF Core 10 with pgvector