Neo4j

Neo4j unterstützt zwei unterschiedliche Agent Framework-Kontextanbietermuster. Sie verwenden eine Diagrammdatenbank, verwenden jedoch separate Pakete und Datenflüsse.

Pattern	Behavior
GraphRAG	Durchsucht ein vorhandenes indiziertes Wissensdiagramm mit Vektor, Volltext oder Hybridabruf und kann verwandte Entitäten mit Cypher durchlaufen.
Beständiger Speicher	Extrahiert Entitäten, Fakten, Vorlieben und Gründe aus Unterhaltungen und erstellt ein Wissensdiagramm, das über Sitzungen hinweg zurückgerufen werden kann.

GraphRAG aus einem vorhandenen Wissensdiagramm

Der Neo4j GraphRAG Context Provider fügt Agent-Framework-Agenten Funktionen zur Retrieval-Augmented Generation (RAG) hinzu, indem er ein Neo4j-Wissensdiagramm verwendet. Es unterstützt Vektor-, Volltext- und Hybridsuchmodi, mit optionalen Diagrammdurchgängen, um Ergebnisse mit verwandten Entitäten über benutzerdefinierte Cypher-Abfragen zu bereichern.

Weitere verwaltete Abrufdienste finden Sie unter Azure KI-Suche und Microsoft Foundry.

Für Wissensdiagrammszenarien, in denen Beziehungen zwischen Entitäten wichtig sind, ruft dieser Anbieter relevante Subgraphen anstelle von isolierten Textblöcken ab, sodass Agents einen umfassenderen Kontext zum Generieren von Antworten erhalten.

Warum Neo4j für GraphRAG verwenden?

Graph enhanced retrieval: Standard vector search returns isolated chunks; Graph-Traversal folgt Verbindungen zu oberflächenbezogenen Entitäten, wodurch Agents umfassenderen Kontext erhalten.
Flexible Suchmodi: Kombinieren von Vektorähnlichkeit, Schlüsselwort/BM25 und Diagrammdurchquerung in einer einzigen Abfrage.
Benutzerdefinierte Abrufabfragen: Cypher-Abfragen ermöglichen Es Ihnen, genau zu steuern, welche Beziehungen durchlaufen werden sollen und welcher Kontext zurückgegeben werden soll.

Voraussetzungen

Eine Neo4j-Instanz (selbst gehostet oder Neo4j AuraDB) mit konfiguriertem Vektor- oder Volltextindex
Ein Azure AI Foundry -Projekt mit einem bereitgestellten Chatmodell und einem Einbettungsmodell (z. B. text-embedding-3-small)
Umgebungsvariablen gesetzt: NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD, AZURE_AI_SERVICES_ENDPOINT, AZURE_AI_EMBEDDING_NAME
Konfigurierte Azure CLI-Anmeldeinformationen (az login)
.NET 8.0 oder höher

Installation

dotnet add package Neo4j.AgentFramework.GraphRAG

Usage

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.OpenAI;
using Microsoft.Extensions.AI;
using Neo4j.AgentFramework.GraphRAG;
using Neo4j.Driver;

// Read connection details from environment variables
var neo4jSettings = new Neo4jSettings();
var azureEndpoint = Environment.GetEnvironmentVariable("AZURE_AI_SERVICES_ENDPOINT")!;

// Create embedding generator
var credential = new DefaultAzureCredential();
var azureClient = new AzureOpenAIClient(new Uri(azureEndpoint), credential);

IEmbeddingGenerator<string, Embedding<float>> embedder = azureClient
    .GetEmbeddingClient("text-embedding-3-small")
    .AsIEmbeddingGenerator();

// Create Neo4j driver
await using var driver = GraphDatabase.Driver(
    neo4jSettings.Uri, AuthTokens.Basic(neo4jSettings.Username, neo4jSettings.Password!));

// Create the Neo4j context provider
await using var provider = new Neo4jContextProvider(driver, new Neo4jContextProviderOptions
{
    IndexName = "chunkEmbeddings",
    IndexType = IndexType.Vector,
    EmbeddingGenerator = embedder,
    TopK = 5,
    RetrievalQuery = """
        MATCH (node)-[:FROM_DOCUMENT]->(doc:Document)
        OPTIONAL MATCH (doc)<-[:FILED]-(company:Company)
        RETURN node.text AS text, score, doc.title AS title, company.name AS company
        ORDER BY score DESC
        """,
});

// Create an agent with the provider
AIAgent agent = azureClient
    .GetChatClient("gpt-4o")
    .AsIChatClient()
    .AsBuilder()
    .UseAIContextProviders(provider)
    .BuildAIAgent(new ChatClientAgentOptions
    {
        ChatOptions = new ChatOptions
        {
            Instructions = "You are a financial analyst assistant.",
        },
    });

var session = await agent.CreateSessionAsync();
Console.WriteLine(await agent.RunAsync("What risks does Acme Corp face?", session));

Wichtigste Funktionen

Indexgesteuert: Funktioniert mit jedem Neo4j-Vektor oder Volltextindex
Graph-Traversal: Benutzerdefinierte Cypher-Abfragen bereichern Suchergebnisse mit verwandten Entitäten
Suchmodi: Vektor (semantische Ähnlichkeit), Volltext (Schlüsselwort/BM25) oder Hybrid (beide kombiniert)

Ressourcen

Voraussetzungen

Eine Neo4j-Instanz (selbst gehostet oder Neo4j AuraDB) mit konfiguriertem Vektor- oder Volltextindex
Ein Azure AI Foundry -Projekt mit einem bereitgestellten Chatmodell und einem Einbettungsmodell (z. B. text-embedding-ada-002)
Umgebungsvariablen gesetzt: NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD, FOUNDRY_PROJECT_ENDPOINT, FOUNDRY_MODEL, AZURE_AI_EMBEDDING_NAME
Konfigurierte Azure CLI-Anmeldeinformationen (az login)
Python 3.10 oder höher

Installation

pip install agent-framework-neo4j

Usage

import os

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from agent_framework_neo4j import Neo4jContextProvider, Neo4jSettings, AzureAISettings, AzureAIEmbedder
from azure.identity import DefaultAzureCredential
from azure.identity.aio import AzureCliCredential

# Reads NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD from environment variables
neo4j_settings = Neo4jSettings()

# Reads FOUNDRY_PROJECT_ENDPOINT, AZURE_AI_EMBEDDING_NAME from environment variables
azure_settings = AzureAISettings()

sync_credential = DefaultAzureCredential()
embedder = AzureAIEmbedder(
    endpoint=azure_settings.inference_endpoint,
    credential=sync_credential,
    model=azure_settings.embedding_model,
)

neo4j_provider = Neo4jContextProvider(
    uri=neo4j_settings.uri,
    username=neo4j_settings.username,
    password=neo4j_settings.get_password(),
    index_name=neo4j_settings.vector_index_name,
    index_type="vector",
    embedder=embedder,
    top_k=5,
    retrieval_query="""
        MATCH (node)-[:FROM_DOCUMENT]->(doc:Document)
        OPTIONAL MATCH (doc)<-[:FILED]-(company:Company)
        RETURN node.text AS text, score, doc.title AS title, company.name AS company
        ORDER BY score DESC
    """,
)

async with (
    neo4j_provider,
    AzureCliCredential() as credential,
    Agent(
        client=FoundryChatClient(
            credential=credential,
            project_endpoint=azure_settings.project_endpoint,
            model=os.environ["FOUNDRY_MODEL"],
        ),
        instructions="You are a financial analyst assistant.",
        context_providers=[neo4j_provider],
    ) as agent,
):
    session = agent.create_session()
    response = await agent.run("What risks does Acme Corp face?", session=session)

Wichtigste Funktionen

Indexgesteuert: Funktioniert mit jedem Neo4j-Vektor oder Volltextindex
Graph-Traversal: Benutzerdefinierte Cypher-Abfragen bereichern Suchergebnisse mit verwandten Entitäten
Suchmodi: Vektor (semantische Ähnlichkeit), Volltext (Schlüsselwort/BM25) oder Hybrid (beide kombiniert)

Ressourcen

Note

Unterstützung für dieses Feature wird in Kürze verfügbar sein. Den neuesten Status finden Sie im Agent Framework Go-Repository .

Speicher für beständigen Agent

Die Neo4j-Speicherintegrationen speichern und rückrufen Agentinteraktionen, extrahieren Automatisch Entitäten und erstellen ein Wissensdiagramm im Laufe der Zeit.

Die Anbieter verwalten:

Kurzzeitspeicher: Aufgezeichnete Unterhaltungen und aktueller Kontext.
Langzeitspeicher: Entitäten, Präferenzen und Fakten, die aus Interaktionen extrahiert werden.
Reasoning memory: Past reasoning traces and tool usage patterns.

Gründe für die Verwendung von Neo4j für den Agent-Speicher?

Wissensdiagramm persistenz: Erinnerungen werden als verbundene Entitäten gespeichert, nicht als flache Datensätze, sodass der Agent gründe für Beziehungen zwischen gespeicherten Informationen kann.
Automatische Entitätsextraktion: Unterhaltungen werden in strukturierte Entitäten und Beziehungen ohne manuell definiertes Schema analysiert.
Sitzungsübergreifender Rückruf: Einstellungen, Fakten und Gründe für Ablaufverfolgungen bleiben über Sitzungen hinweg und werden über Kontextanbieter hinweg beibehalten.

Note

Das .NET-Paket (AgentMemory) ist ein unabhängiger, von der Community verwalteter .NET Port des Neo4j Labs-Speicheranbieters. Es ist kein offizielles Neo4j Labs-Paket. Weitere Informationen finden Sie im AgentMemory-Repository (.NET).

Voraussetzungen

Eine Neo4j-Instanz (selbst gehostet oder Neo4j AuraDB).
Eine Azure OpenAI- oder Microsoft Foundry-Bereitstellung mit einem Chatmodell und einem Einbettungsmodell.
Umgebungsvariablen: NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD, . AZURE_OPENAI_ENDPOINT
Azure CLI konfigurierten Anmeldeinformationen (az login) oder einen API-Schlüssel.
.NET 8.0 oder höher.

Installation

dotnet add package AgentMemory
dotnet add package AgentMemory.AgentFramework

Usage

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using AgentMemory;
using AgentMemory.Abstractions.Services;
using AgentMemory.AgentFramework;
using AgentMemory.AgentFramework.Tools;

var builder = Host.CreateApplicationBuilder(args);

// Registers Core + Neo4j infrastructure in one call (reads NEO4J_URI / NEO4J_USERNAME /
// NEO4J_PASSWORD, falling back to local-dev defaults). Passing configureLlm opts in to
// LLM-backed entity/fact/preference extraction, using the IChatClient registered below.
builder.Services.AddNeo4jAgentMemory(
    configureMemory: _ => { },
    configureNeo4j: neo4j =>
    {
        neo4j.Uri = Environment.GetEnvironmentVariable("NEO4J_URI") ?? "bolt://localhost:7687";
        neo4j.Username = Environment.GetEnvironmentVariable("NEO4J_USERNAME") ?? "neo4j";
        neo4j.Password = Environment.GetEnvironmentVariable("NEO4J_PASSWORD") ?? "password";
    },
    configureLlm: _ => { });

// Any Microsoft.Extensions.AI-compatible chat + embedding client works
var azureClient = new AzureOpenAIClient(
    new Uri(Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")!), new DefaultAzureCredential());
builder.Services.AddSingleton(azureClient.GetChatClient("gpt-4o-mini").AsIChatClient());
builder.Services.AddSingleton(azureClient.GetEmbeddingClient("text-embedding-3-small").AsIEmbeddingGenerator());

// AutoExtractOnPersist builds the knowledge graph from every conversation turn
builder.Services.AddAgentMemoryFramework(options =>
{
    options.AutoExtractOnPersist = true;
    options.ContextFormat.IncludeEntities = true;
    options.ContextFormat.IncludeFacts = true;
    options.ContextFormat.IncludePreferences = true;
});

using var host = builder.Build();
await using var scope = host.Services.CreateAsyncScope();
var services = scope.ServiceProvider;

// Bootstraps Neo4j schema/indexes on first run (idempotent)
await services.GetRequiredService<ISchemaBootstrapper>().BootstrapAsync();

var memoryProvider = services.GetRequiredService<Neo4jMemoryContextProvider>();
var memoryTools = services.GetRequiredService<MemoryToolFactory>().CreateAIFunctions();

// WithMemoryOwnerScoping wraps the whole invocation — recall, the tool-calling loop, and
// persistence — in the owner scope set by WithMemoryIdentity below, so no manual
// BeginOwnerScope call is needed around RunAsync.
AIAgent agent = services.GetRequiredService<IChatClient>().AsAIAgent(new ChatClientAgentOptions
{
    ChatOptions = new ChatOptions
    {
        Instructions = "You are a helpful assistant with persistent memory.",
        Tools = [.. memoryTools],
    },
    AIContextProviders = [memoryProvider],
}).WithMemoryOwnerScoping(services);

var session = (await agent.CreateSessionAsync())
    .WithMemoryIdentity(userId: "user-123", sessionId: "session-1", applicationId: "my-app");

var response = await agent.RunAsync("Remember that I prefer window seats on flights.", session);

Wichtigste Funktionen

Bidirektional: Neo4jMemoryContextProvider Ruft den relevanten Speicher vor jeder Ausführung zurück und speichert danach neuen Speicher.
Entitätsextraktion: Die konfigurierbare Extraktionspipeline erstellt ein Wissensdiagramm aus Unterhaltungen.
Einstellungslernen: Einstellungen, Fakten und Entitäten können von einem neuen AgentSession für denselben Benutzer zurückgerufen werden.
Speichertools: MemoryToolFactory stellt Instanzen für explizite Such-, Erinnerungs AIFunction - und Rückrufvorgänge zur Verfügung.
Abhängigkeitsinjektion zuerst: AddNeo4jAgentMemory und AddAgentMemoryFramework in generische Host- und ASP.NET Core-Anwendungen integriert.
Beyond Agent Framework: Die gleiche Bibliothek ist auch in Semantischer Kernel- und MCP-Clients integriert und umfasst OpenTelemetry Observability.

Ressourcen

Voraussetzungen

Eine Neo4j-Instanz (selbst gehostet oder Neo4j AuraDB).
Ein Microsoft Foundry-Projekt mit einem bereitgestellten Chatmodell.
Ein OpenAI-API-Schlüssel oder Azure OpenAI-Bereitstellung für Einbettungen und Entitätsextraktion.
Umgebungsvariablen: NEO4J_URI, NEO4J_PASSWORD, FOUNDRY_PROJECT_ENDPOINT, FOUNDRY_MODEL, . OPENAI_API_KEY
Azure CLI konfigurierten Anmeldeinformationen (az login).
Python 3.10 oder höher.

Installation

pip install neo4j-agent-memory[microsoft-agent]

Usage

import os
from pydantic import SecretStr
from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity.aio import AzureCliCredential
from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.integrations.microsoft_agent import (
    Neo4jMicrosoftMemory,
    create_memory_tools,
)

# Pass Neo4j and embedding configuration directly via constructor arguments.
# MemorySettings also supports loading from environment variables or .env files
# using the NAM_ prefix (e.g. NAM_NEO4J__URI, NAM_EMBEDDING__MODEL).
settings = MemorySettings(
    neo4j={
        "uri": os.environ["NEO4J_URI"],
        "username": os.environ.get("NEO4J_USERNAME", "neo4j"),
        "password": SecretStr(os.environ["NEO4J_PASSWORD"]),
    },
    embedding={
        "provider": "openai",
        "model": "text-embedding-3-small",
    },
)

memory_client = MemoryClient(settings)

async with memory_client:
    memory = Neo4jMicrosoftMemory.from_memory_client(
        memory_client=memory_client,
        session_id="user-123",
    )
    tools = create_memory_tools(memory)

    async with AzureCliCredential() as credential, Agent(
        client=FoundryChatClient(
            credential=credential,
            project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
            model=os.environ["FOUNDRY_MODEL"],
        ),
        instructions="You are a helpful assistant with persistent memory.",
        tools=tools,
        context_providers=[memory.context_provider],
    ) as agent:
        session = agent.create_session()
        response = await agent.run("Remember that I prefer window seats on flights.", session=session)

Wichtigste Funktionen

Bidirektional: Ruft den relevanten Kontext vor dem Aufruf ab und speichert neue Erinnerungen nach Antworten.
Entitätsextraktion: Erstellt ein Wissensdiagramm aus Unterhaltungen mit einer mehrstufigen Extraktionspipeline.
Einstellungslernen: Leitet Benutzereinstellungen in Sitzungen ab und speichert sie.
Speichertools: Ermöglicht Es Agents, Arbeitsspeicher explizit zu durchsuchen, Einstellungen zu speichern und Entitätsverbindungen zu finden.

Ressourcen

Note

Neo4j GraphRAG und Speicherintegrationen sind derzeit nicht für Agent Framework Go dokumentiert. Den neuesten Status finden Sie im Agent Framework Go-Repository .

Nächste Schritte

Durchsuchen von Kontextanbieterintegrationen

Feedback

War diese Seite hilfreich?

Last updated on 2026-08-13

Neo4j

GraphRAG aus einem vorhandenen Wissensdiagramm

Warum Neo4j für GraphRAG verwenden?

Voraussetzungen

Installation

Usage

Wichtigste Funktionen

Ressourcen

Voraussetzungen

Installation

Usage

Wichtigste Funktionen

Ressourcen

Speicher für beständigen Agent

Gründe für die Verwendung von Neo4j für den Agent-Speicher?

Voraussetzungen

Installation

Usage

Wichtigste Funktionen

Ressourcen

Voraussetzungen

Installation

Usage

Wichtigste Funktionen

Ressourcen

Nächste Schritte

Feedback

Zusätzliche Ressourcen