Use with LangChain

# Chat history + retriever only
pip install "neo4j-agent-memory[langchain,openai]"

# Plus the create_agent middleware
pip install "neo4j-agent-memory[langchain-agents,openai]" langchain-openai

import os

from langchain_openai import ChatOpenAI

from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.integrations.langchain import (
    llm_provider_from_langchain,
)

# Configure your LangChain model however you normally would. Temperature is
# left at the provider default: the GPT-5 family rejects non-default values.
chat = ChatOpenAI(model=os.getenv("OPENAI_MODEL", "gpt-5-mini"))

# Convert it to an LLMProvider for the memory client.
provider = llm_provider_from_langchain(chat)

settings = MemorySettings(
    neo4j={"password": os.environ["NEO4J_PASSWORD"]},
    llm=provider,
    embedding="openai/text-embedding-3-small",
)

import asyncio
import os

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from pydantic import SecretStr

from neo4j_agent_memory import BoltSettings, MemoryClient, Neo4jConfig
from neo4j_agent_memory.integrations.langchain import (
    Neo4jMemoryMiddleware,
    llm_provider_from_langchain,
)


async def main() -> None:
    model = ChatOpenAI(model=os.getenv("OPENAI_MODEL", "gpt-5-mini"))

    settings = BoltSettings(
        neo4j=Neo4jConfig(
            uri=os.getenv("NEO4J_URI", "bolt://localhost:7687"),
            password=SecretStr(os.environ["NEO4J_PASSWORD"]),
        ),
        embedding="openai/text-embedding-3-small",
        llm=llm_provider_from_langchain(model),
    )

    async with MemoryClient(settings) as client:
        agent = create_agent(
            model,
            tools=[],
            system_prompt="You are a helpful assistant.",
            middleware=[
                Neo4jMemoryMiddleware(client, session_id="user-123"),
            ],
        )

        # Async invocation: the middleware implements the async hooks.
        result = await agent.ainvoke(
            {"messages": [("user", "Where should I eat tonight?")]}
        )
        print(result["messages"][-1].content)


asyncio.run(main())

Neo4jMemoryMiddleware(
    client,
    session_id="user-123",
    include_short_term=True,   # conversation history in the injected block
    include_long_term=True,    # entities, facts and preferences
    include_reasoning=True,    # similar past traces
    max_items=10,              # per-layer cap
    store_messages=True,       # set False for a read-only agent
    extract_entities=True,     # entity extraction on persisted messages
    context_header="# Memory",
)

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory

from neo4j_agent_memory.integrations.langchain import Neo4jAgentMemory

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a helpful assistant."),
        MessagesPlaceholder("history"),
        ("human", "{input}"),
    ]
)
chain = prompt | model | StrOutputParser()

chain_with_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: Neo4jAgentMemory(memory_client=client, session_id=session_id),
    input_messages_key="input",
    history_messages_key="history",
)

answer = await chain_with_history.ainvoke(
    {"input": "I'm looking for running shoes"},
    config={"configurable": {"session_id": "user-123"}},
)

from neo4j_agent_memory.integrations.langchain import Neo4jMemoryRetriever

retriever = Neo4jMemoryRetriever(
    memory_client=client,
    session_id="user-123",     # scopes message search
    search_short_term=True,    # messages
    search_long_term=True,     # entities + preferences
    search_reasoning=True,     # reasoning traces
    k=10,
    threshold=0.7,
)

docs = await retriever.ainvoke("spicy food preferences")
for doc in docs:
    print(doc.metadata["type"], "-", doc.page_content)

from langchain_core.tools.retriever import create_retriever_tool

search_memory = create_retriever_tool(
    retriever,
    "search_memory",
    "Search the user's memory: past messages, known entities, saved preferences.",
)

# agent = create_agent(model, tools=[search_memory], middleware=[...])

from typing import Any

from langchain.agents.middleware import AgentMiddleware, AgentState
from langchain_core.messages import AIMessage, HumanMessage

from neo4j_agent_memory import MemoryClient
from neo4j_agent_memory.schema.models import TraceOutcome


class ReasoningTraceMiddleware(AgentMiddleware):
    """Record each agent run as a reasoning trace."""

    def __init__(self, client: MemoryClient, session_id: str) -> None:
        super().__init__()
        self.client = client
        self.session_id = session_id
        self.tools = []

    async def abefore_agent(self, state: AgentState, runtime: Any) -> None:
        task = next(
            (m.text for m in reversed(state["messages"]) if isinstance(m, HumanMessage)),
            "",
        )
        trace = await self.client.reasoning.start_trace(self.session_id, task)
        self._trace_id = trace.id

    async def aafter_model(self, state: AgentState, runtime: Any) -> None:
        last = state["messages"][-1]
        if not isinstance(last, AIMessage):
            return
        step = await self.client.reasoning.add_step(
            self._trace_id,
            thought=last.text or "(tool call only)",
            action=", ".join(c["name"] for c in last.tool_calls) or "respond",
        )
        for call in last.tool_calls:
            await self.client.reasoning.record_tool_call(
                step.id,
                call["name"],
                call["args"],
            )

    async def aafter_agent(self, state: AgentState, runtime: Any) -> None:
        await self.client.reasoning.complete_trace(
            self._trace_id,
            outcome=TraceOutcome(
                success=True,
                summary=state["messages"][-1].text[:200],
                metrics={"model_calls": float(len(state["messages"]))},
            ),
        )

agent = create_agent(
    model,
    tools=tools,
    middleware=[
        Neo4jMemoryMiddleware(client, session_id=session_id),
        ReasoningTraceMiddleware(client, session_id=session_id),
    ],
)

from neo4j_agent_memory import MemoryClient, MemorySettings

# Hosted: reads MEMORY_API_KEY (and optionally MEMORY_WORKSPACE_ID)
settings = MemorySettings(backend="nams")

async with MemoryClient(settings) as client:
    history = Neo4jAgentMemory(
        memory_client=client,
        session_id="user-123",
        include_reasoning=False,  # no trace search on NAMS
    )