AgentMemory.Nams 2.1.0

Agent Memory for .NET

A native .NET reimplementation of graph-native agent memory, inspired by Neo4j Agent Memory and verified against its compatibility kit.

Independent community project. Not affiliated with, endorsed by, or supported by Neo4j, Inc. Not related to the similarly named agentmemory package on npm.

Give your .NET agents a memory that actually lasts. Agent Memory for .NET is a persistent, graph-native memory engine for AI agents, backed by Neo4j — so what your agent learns in one conversation is still there, structured and queryable, in the next one. Built for the Microsoft Agent Framework, Semantic Kernel, direct .NET usage, and MCP clients.

Research paper

ampack: signed, declaratively traversable memory packs for AI agents, with trial-gated activation
José Luis Latorre Millas, 2026.

Read the preprint on Zenodo

The paper is licensed under CC BY 4.0. Software licensing is described in LICENSING.md.

Project Status

This is an early-stage, actively-developed open-source project, not a mature commercial product with an SLA or support contract. It's maintained by its author on a best-effort basis. Expect rough edges: bugs and edge cases are likely to surface as real-world usage broadens, especially just after a release.

Issues are genuinely welcome — please open one for bugs, gaps, or unexpected behavior. They get triaged and fixed as they're found, not ignored, but turnaround depends on available time, not a guaranteed response window. Review the Threat Model and Production Checklist before production use, pin versions deliberately, and check the CHANGELOG between upgrades. As with any permissively licensed software, it is provided as is, without warranty (see Licensing).

Why Agent Memory for .NET

• Memory that survives the session. Conversations, facts, preferences, and relationships persist as a real knowledge graph, not a scratchpad that evaporates when the process exits.
• Three memory layers, not one. Short-term conversation history, long-term facts/preferences/entities, and reasoning traces (steps, tool calls, prior executions) are all first-class citizens.
• Graph-native, not just vectors. Vector, fulltext, hybrid, and graph-traversal retrieval, plus optional GraphRAG context — because "similar text" and "connected knowledge" are different questions.
• Multi-tenant capable. Owner and store isolation are enforced throughout scoped repository, recall, GraphRAG, reasoning, maintenance, and agent-tool operations. Multi-tenant hosts must establish an owner scope for every agent run. Unscoped operations retain global behavior for administrative and single-tenant scenarios. One deliberate exception, stated precisely: short-term messages are addressed by handle. :Message nodes carry no owner_id, and reading a session's messages by session id performs no owner check — a session id is itself the capability. Long-term memory, recall, and session clearing are all owner-scoped; short-term reads by handle are not. Treat session ids as secrets, and reach short-term history through recall when you want owner enforcement.
• Time-aware. Bitemporal recall and non-destructive decay mean memory can answer "what did we believe back then" as well as "what do we believe now."
• Drops into the ecosystem you already use. First-class adapters for the Microsoft Agent Framework, Semantic Kernel, and MCP, plus a direct .NET API for everything else.
• Fits the .NET you already run. Multi-targets net8.0, net9.0, and net10.0, so adopting it doesn't mean adopting a new runtime first.
• Faithful to its roots. Verified against the upstream Python neo4j-labs/agent-memory project's own compatibility kit, so the .NET reimplementation isn't just inspired by the original — it's checked against it.

Memory Governance

Any memory system that spans tenants, sessions, and time needs to answer these questions structurally — not by convention. AgentMemory does:

Quick Start

dotnet add package AgentMemory

using AgentMemory;
using AgentMemory.Abstractions.Services;
using AgentMemory.Neo4j.Infrastructure;
using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();

services.AddNeo4jAgentMemory(
    memory => { },
    neo4j =>
    {
        neo4j.Uri = "bolt://localhost:7687";
        neo4j.Username = "neo4j";
        neo4j.Password = "password";
    },
    configureLlm: null);

var provider = services.BuildServiceProvider();

var bootstrapper = provider.GetRequiredService<ISchemaBootstrapper>();
await bootstrapper.BootstrapAsync();

var memory = provider.GetRequiredService<IMemoryService>();
await memory.AddMessageAsync("session-01", "conversation-01", "user", "I prefer dark mode.");

For production semantic search, register a real IEmbeddingGenerator<string, Embedding<float>> from Microsoft.Extensions.AI; the core stubs are safe defaults, not production embeddings.

Documentation

Full documentation lives in docs/ — start with Getting Started:

• Getting Started
• Architecture
• The Memory Map - what this memory layer does, does partially, and does not do, with each claim labelled built / wired / measured
• Agent Framework Integration
• Schema Reference
• Schema Extensions - optional, additive-only schema modules a capability can bring with it; none is active by default, and each one's DDL is applied by an operator, not by application startup
• Specification
• Neo4j Memory Ecosystem - schema-parity/TCK compatibility tooling and the review process behind releases
• Threat Model - what isolation/authorization properties hold today, what's a documented gap, and who owns closing it
• Production Checklist - what a deployment must configure itself (AgentMemory can't guarantee these alone)

See SECURITY.md to report a vulnerability.

Relationship to Upstream

This project is inspired by neo4j-labs/agent-memory — the Python reference implementation — and preserves compatible graph concepts from its schema where useful. But it's a from-scratch .NET reimplementation, not a port: it shares no code with the Python project. Most of what it needs — the Neo4j driver integration, extraction pipeline, embeddings, DI wiring, and the Microsoft Agent Framework/Semantic Kernel/MCP adapters — has no ready-made equivalent in the .NET ecosystem to lean on, so it was built natively rather than bound or ported. It is not an official Neo4j repository or product; schema and behavioral compatibility with the original are verified explicitly (see Neo4j Memory Ecosystem).

Memory packs and the preprint

Version 2.0.0 adds ampack, a format for memory packs that a host verifies, walks within declared budgets and switches on only after a trial on its own work. The format, the admission procedure and the evidence behind them are described in a preprint (not peer reviewed):

José Luis Latorre Millas. ampack: signed, declaratively traversable memory packs for AI agents, with trial-gated activation. Preprint, version 0.10, 5 November 2026. doi:10.5281/zenodo.24012989

The specification is in spec/, the conformance kit in conformance/, and a citation file in CITATION.cff. The evidence behind the preprint (the signed trial decisions with their public keys and a verifier, the conformance runs, the measurement commits) is attached to the 2.0.0 release.

Related projects

• GraphBridge: an Entity Framework Core provider for Neo4j, from the same author, with an experimental GraphRAG toolkit for .NET. Its answers show the stored text each quote came from, or say why they can't answer, and its graphs can be shared with neo4j-graphrag.

Contributing

See CONTRIBUTING.md for build, test, and contribution guidance.

Licensing

Three licences live in this repository from version 2.0.0: two for code, project by project, and one for the specification. The complete map, with what each licence asks of you and why the root LICENSE file stays MIT, is LICENSING.md.

Why two code licences: the Apache-2.0 projects implement the ampack format and its host procedure, on which the author has filed a patent application (pending, not granted). Apache-2.0 section 3 gives every user of that code an express patent licence; MIT has no express patent-grant clause. The core library stays MIT as it has been since its first release. Each Apache-2.0 project carries its own LICENSE and NOTICE, its source files carry an SPDX header, and its package declares Apache-2.0. For implementations of the specification that do not use this code, PATENTS.md holds a proposed patent non-assertion pledge: royalty-free for conforming implementations of the listed specification versions, with the conditions stated there. It is a draft until the author issues it; until then it grants nothing. "2.0.0" names the repository release; package versions differ by project. The root LICENSE file is the MIT licence that applies where no project-level licence says otherwise.