Entity Framework Core

McpEssentials.EntityFrameworkCore is the first durable authenticated task store. It subclasses McpTaskStoreBase and persists McpTaskEntity rows through your DbContext.

Any EF provider

SQL Server, SQLite, PostgreSQL, MySQL, MariaDB, Cosmos via EF, Oracle — whatever you already pass to AddDbContext.

Host owns the model

Your context, your connection, your migrations. The store opens a scope per operation.

Optional bus

Multi-node ElicitAsync takes IMcpTaskInputSignalBus.

This package works with any EF Core database provider. The store talks to TContext.Set<McpTaskEntity>(); it never binds a specific engine.

The host owns the context, the connection, and migrations. This package ships the entity, AddMcpTasksTable on ModelBuilder and on DbContextOptionsBuilder, and a singleton store that opens a scope per operation so a standard scoped AddDbContext works.

Install

dotnet add package McpEssentials.EntityFrameworkCore

builder.Services.AddDbContext<AppDbContext>(o => o.UseSqlServer(connectionString));

builder.Services.AddDbContext<AppDbContext>(o => o.UseSqlite("Data Source=app.db"));

builder.Services.AddDbContext<AppDbContext>(o => o.UseNpgsql(connectionString));

builder.Services.AddDbContext<AppDbContext>(o => o.UseCosmos(accountEndpoint, accountKey, databaseName));

builder.Services.AddDbContext<AppDbContext>(o => o.UseMySql(connectionString, serverVersion));

Map the table

Keep MCP task rows on their own table; they expire in minutes. The default name is McpTasks. Pass a name and schema on either call to change it: AddMcpTasksTable("AppTasks", "mcp"). The store talks to TContext.Set<McpTaskEntity>(). The host does not need a DbSet. Both options use the same host DbContext. Pick one.

OnModelCreating
AddDbContext

Use this in a single-project app, or whenever the project that owns AppDbContext already references this package. Mapping lives with the rest of the model. Migrations from that project see the table.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.AddMcpTasksTable();
}

Use this when AppDbContext lives in a class library that must stay free of MCP. Only the application project takes this package. Call AddMcpTasksTable on the options next to UseSqlServer (or whatever provider you already use). EF still uses the same host DbContext; the mapping runs after OnModelCreating.

builder.Services.AddDbContext<AppDbContext>(o =>
{
    o.UseSqlServer(connectionString);
    o.AddMcpTasksTable();
});

Run migrations with the application as the startup project so the options hook is in the model:

dotnet ef migrations add AddMcpTasks --startup-project path/to/App

A migration from the context project alone will not see McpTasks and can emit a drop.

Mapped columns include TaskId, OwnerUserId, Status (enum name as string), timestamps, TimeToLive, ExpiresAt, DiscardAfter (UTC ticks so every provider, including SQLite, can ExecuteDelete), JSON payloads, and an application-managed RowVersion. Indexes cover owner, (OwnerUserId, TaskId), ExpiresAt, and DiscardAfter. SQL Server hosts may remap RowVersion as rowversion in their own configuration.

Wire the store

Same identity factory as Authenticated tasks. The SDK WithTasks API captures the store before Build(); WithTasksPlus stamps the provider on first use. Register the store as a singleton. The context stays scoped. Each operation opens an IServiceScope, resolves TContext, and disposes the scope.

HTTP
Stdio
Store only

builder.Services.AddHttpContextAccessor();
builder.Services.AddDbContext<AppDbContext>(o => o.UseSqlServer(connectionString));

builder.Services.AddMcpServer()
    .WithHttpTransport(o => o.Stateless = true)
    .WithTools<MyTools>()
    .WithTasksPlus<AppDbContext>(
        sp => sp.GetRequiredService<IHttpContextAccessor>().HttpContext?.User,
        o => o.DefaultTimeToLive = TimeSpan.FromMinutes(5));

builder.Services.AddDbContext<AppDbContext>(o => o.UseSqlite("Data Source=tasks.db"));
builder.Services.AddMcpServer()
    .WithTasksPlus<AppDbContext>("local-user");

Same factory, without IMcpServerBuilder:

builder.Services.AddHttpContextAccessor();
builder.Services.AddDbContext<AppDbContext>(o => o.UseSqlServer(connectionString));
builder.Services.AddMcpEssentialsEntityFrameworkTasks<AppDbContext>(
    sp => sp.GetRequiredService<IHttpContextAccessor>().HttpContext?.User,
    o => o.DefaultTimeToLive = TimeSpan.FromMinutes(5));

Options

Pass Action<McpTaskStoreOptions> as the next argument after identity.

Knob	Default	Role
`DefaultTimeToLive`	`null` (unlimited)	Work window ends at `CreatedAt + TTL`. The row is discarded at `CreatedAt + 2×TTL` (`DiscardAfter`), or sooner on a terminal owner get.
`DefaultPollIntervalMs`	`1000`	Hint for clients.
`AutoSweep`	`true`	Pulse a throttled flush after create and on get.
`SweepInterval`	30 seconds	Minimum time between automatic pulses. `TimeSpan.Zero` skips the throttle.
`ServeAndDrop`	`true`	Owner get of a terminal snapshot serves it and then deletes the row.

.WithTasksPlus<AppDbContext>(currentUser, o =>
{
    o.DefaultTimeToLive = TimeSpan.FromMinutes(5);
    o.AutoSweep = false;          // you own the schedule
    o.ServeAndDrop = true;
});

Call SweepExpiredAsync from a hosted service or SQL Agent wrapper when AutoSweep is off. The public handle always runs a full pass. The EF drain is a set-delete: DELETE WHERE DiscardAfter IS NOT NULL AND DiscardAfter <= now. It does not load the table. SQLite stores DiscardAfter as UTC ticks so that comparison translates; SQL Server and PostgreSQL use the same path. Per-row get and mutate still use ShouldDiscard (default HasExpired). Override SweepExpiredCoreAsync when bulk criteria must differ from the stamp.

Events

A single instance raises InputResponseReceived in-process. Several nodes that wait on ElicitAsync need a bus: register IMcpTaskInputSignalBus in DI (Redis, Service Bus, …). The store publishes after a successful resolve and subscribes so the originating process wakes up. Payload is task id plus request id. Keep tokens and elicitation secrets off the bus; the row already has the response body.

Missing bus plus multiple nodes means elicitation waits until timeout. That is a host misconfiguration.

Isolation

CreateTaskAsync stamps OwnerUserId. Client-facing get, cancel, and resolve require that user. Another user’s task is not found. Server-side complete, fail, and set-input skip the live-user check because the SDK runs those from a background DI scope after the originating HTTP request is gone.

When to use a native package instead

Stay on this package when the host already uses EF Core.

PostgreSQL

Npgsql or Dapper, and LISTEN / NOTIFY, with no DbContext.

SQL Server

ADO.NET or Dapper only. Specified; use this package with UseSqlServer until it ships.

Sample

Runnable SQLite host.

Stores

Pick a backing store by the engine you already run.

Authenticated tasks

Identity factory, isolation rules, and the in-memory store.

Cosmos DB

Native Cosmos when you want in-partition point reads instead of UseCosmos.

Getting Started

API Reference

Entity Framework Core

Any EF provider

Host owns the model

Optional bus

Install

Map the table

Wire the store

Options

Events

Isolation

When to use a native package instead

PostgreSQL

SQL Server

Sample

Stores

Authenticated tasks

Cosmos DB

Any EF provider

Host owns the model

Optional bus

​Install

​Map the table

​Wire the store

​Options

​Events

​Isolation

​When to use a native package instead

PostgreSQL

SQL Server

​Related

Sample

Stores

Authenticated tasks

Cosmos DB

Install

Map the table

Wire the store

Options

Events

Isolation

When to use a native package instead

Related