LangChain & LangGraph

pip install langchain-memstate

from langchain_memstate import MemstateStore, get_memstate_tools
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# 1. Create the store
store = MemstateStore(api_key="mst_...", project_id="my-agent")

# 2. Give the agent tools to interact with memory directly
tools = get_memstate_tools(api_key="mst_...", project_id="my-agent")

# 3. Create the agent
agent = create_react_agent(
    ChatOpenAI(model="gpt-4o-mini"),
    tools=tools,
    store=store,
)

# 4. Run it
result = agent.invoke({
    "messages": [{"role": "user", "content": "Remember that Alice prefers Python for backend work"}]
})

from langchain_memstate import MemstateStore

store = MemstateStore(api_key="mst_...", project_id="my-project")

# Store facts at structured keypaths — like a filesystem for knowledge
store.put(("users", "alice", "preferences"), "language",   {"value": "Python"})
store.put(("users", "alice", "preferences"), "framework",  {"value": "FastAPI"})
store.put(("users", "alice"),                "role",       {"value": "Senior Backend Engineer"})
store.put(("project", "myapp", "auth"),      "provider",   {"value": "OAuth2 + JWT"})
store.put(("project", "myapp", "database"),  "engine",     {"value": "PostgreSQL 16"})
store.put(("project", "myapp", "cache"),     "engine",     {"value": "Redis 7"})

# Retrieve a specific fact by its exact keypath
item = store.get(("users", "alice", "preferences"), "language")
print(item.value)  # {"value": "Python"}
print(item.namespace)  # ('users', 'alice', 'preferences')
print(item.key)        # 'language'

# Semantic search — finds the most relevant memories across the whole tree
results = store.search(("users",), query="what does alice prefer for backend work?")
for r in results:
    print(f"[{'.'.join(r.namespace)}.{r.key}] score={r.score:.3f}")
    print(f"  {r.value}")

# Browse the entire knowledge tree under a prefix
tree = store.browse(("project", "myapp"))
for keypath, summary in tree.items():
    print(f"  {keypath}: {summary}")

from langchain_memstate import MemstateStore

store = MemstateStore(api_key="mst_...", project_id="my-project")

# What did the agent know about the project at revision 5?
# This reconstructs the exact state of memory at that point in time.
snapshot = store.get_at_revision(("project", "myapp"), at_revision=5)

print("Project state at revision 5:")
for keypath, summary in snapshot.items():
    print(f"  {keypath}: {summary}")

# Useful for:
# - Debugging: "What did the agent know when it made that decision?"
# - Auditing: "How has our architecture evolved over time?"
# - Rollback: "What was the correct value before the bad update?"

from langchain_memstate import get_memstate_tools
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# Get all 6 Memstate tools
tools = get_memstate_tools(api_key="mst_...", project_id="my-agent")

# Or select specific tools
tools = get_memstate_tools(
    api_key="mst_...",
    project_id="my-agent",
    include_tools=["remember", "recall", "browse"],  # skip store, history + time_travel
)

agent = create_react_agent(ChatOpenAI(model="gpt-4o-mini"), tools)

# The agent can now:
# - memstate_remember: Auto-extract facts from any text (recommended primary tool)
# - memstate_store: Store a specific value at an exact keypath (precise writes)
# - memstate_recall: Semantic search across all memories
# - memstate_browse: Browse the knowledge tree by keypath prefix
# - memstate_get_history: See how a fact has changed over time
# - memstate_time_travel: Reconstruct memory state at any past revision
result = agent.invoke({"messages": [
    {"role": "user", "content": (
        "I'm starting work on the myapp project. "
        "First check what you already know about it, "
        "then remember that we're adding a new payments module using Stripe."
    )}
]})
print(result["messages"][-1].content)

from langchain_memstate import MemstateRetriever
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI

# Use Memstate as a retriever in any LangChain RAG pipeline
retriever = MemstateRetriever(
    api_key="mst_...",
    project_id="my-agent",
    k=5,                    # return top 5 results
    score_threshold=0.3,    # filter out low-relevance results
)

# Drop it into RetrievalQA
qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o-mini"),
    retriever=retriever,
)

answer = qa_chain.invoke({"query": "What database does myapp use?"})
print(answer["result"])

# Or use it directly
docs = retriever.invoke("authentication provider for myapp")
for doc in docs:
    print(f"[{doc.metadata['keypath']}] score={doc.metadata['score']:.3f}")
    print(f"  {doc.page_content}")

from langchain_memstate import MemstateChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# Build a chain with persistent conversation history
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}"),
])

chain = prompt | ChatOpenAI(model="gpt-4o-mini")

chain_with_history = RunnableWithMessageHistory(
    chain,
    # Each session_id gets its own conversation stored in Memstate
    lambda session_id: MemstateChatMessageHistory(
        api_key="mst_...",
        session_id=session_id,
        project_id="my-chatbot",
    ),
    input_messages_key="input",
    history_messages_key="history",
)

# Session 1 — first conversation
response = chain_with_history.invoke(
    {"input": "My name is Alice and I prefer Python."},
    config={"configurable": {"session_id": "alice-session-1"}},
)

# Session 1 — later in the same session (history is preserved)
response = chain_with_history.invoke(
    {"input": "What programming language do I prefer?"},
    config={"configurable": {"session_id": "alice-session-1"}},
)
print(response.content)  # "You mentioned you prefer Python."

"""
Full demo: A project architect agent that builds a living knowledge graph.

This demo shows Memstate's unique strengths:
1. Keypath hierarchy — facts organized like a filesystem
2. Automatic versioning — every update preserves history
3. Semantic search — find facts by meaning, not just exact path
4. Time-travel — reconstruct what the agent knew at any point
"""

import os
from langchain_memstate import MemstateStore, get_memstate_tools
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

API_KEY = os.environ["MEMSTATE_API_KEY"]
PROJECT_ID = "demo-architect-agent"

store = MemstateStore(api_key=API_KEY, project_id=PROJECT_ID)
tools = get_memstate_tools(api_key=API_KEY, project_id=PROJECT_ID)

agent = create_react_agent(
    ChatOpenAI(model="gpt-4o-mini"),
    tools=tools,
    store=store,
    prompt=(
        "You are a software architect agent. You maintain a structured knowledge graph "
        "about the project using Memstate. Use keypaths like 'project.myapp.auth.provider' "
        "to organize facts hierarchically. Always check what you already know before "
        "answering, and always remember new information you learn."
    ),
)

# Turn 1: Learn the initial architecture
agent.invoke({"messages": [{"role": "user", "content": """
    Here's our initial architecture:
    - Database: PostgreSQL 14
    - Auth: Basic Auth with bcrypt
    - Cache: None
    - Frontend: React 17
    - Backend: Python/Flask
    Please remember all of this.
"""}]})

# Turn 2: Architecture evolves — Memstate auto-versions each change
agent.invoke({"messages": [{"role": "user", "content": """
    We've upgraded:
    - Database: PostgreSQL 16 (added pgvector)
    - Auth: Migrated to OAuth2 + JWT
    - Cache: Added Redis 7
    - Frontend: Upgraded to React 18
    Please update your memory.
"""}]})

# Turn 3: Query the current state
result = agent.invoke({"messages": [{"role": "user", "content":
    "Give me a full overview of our current architecture."
}]})
print("Current architecture:")
print(result["messages"][-1].content)

# Turn 4: Time-travel — what did we know at the start?
print("\n--- Direct time-travel query ---")
snapshot = store.get_at_revision(("project",), at_revision=1)
print("Architecture at revision 1:")
for keypath, summary in snapshot.items():
    print(f"  {keypath}: {summary}")

# Turn 5: See the full version history for auth
print("\n--- Auth provider version history ---")
history = store.get_history(("project", "myapp", "auth"), "provider")
for v in history:
    print(f"  v{v['version']}: {v.get('summary', '')}")