AgentMemory 1.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.

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.

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 MIT-licensed software, it's provided as-is, without warranty (see License).

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.
• 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
• Agent Framework Integration
• Schema Reference
• 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).

Contributing

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

License

This project is licensed under the MIT License.