LangMem

https://langchain-ai.github.io/langmem
Admin
LangMem helps agents learn and adapt from their interactions over time, providing tooling to extract...
Tokens:40,846
Snippets:313
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### MultiPromptOptimizerInput Example

Source: https://langchain-ai.github.io/langmem/reference/prompt_optimization

An example demonstrating the structure of MultiPromptOptimizerInput, used for optimizing multiple prompts while maintaining consistency. It includes conversation trajectories and prompt definitions.

```python
{
    "trajectories": [
        AnnotatedTrajectory(
            messages=[
                {"role": "user", "content": "Tell me about this image"},
                {
                    "role": "assistant",
                    "content": "I see a dog playing in a park",
                },
                {"role": "user", "content": "What breed is it?"},
                {
                    "role": "assistant",
                    "content": "Sorry, I can't tell the breed",
                },
            ],
            feedback="Vision model wasn't used for breed detection",
        ),
    ],
    "prompts": [
        Prompt(
            name="vision_extract",
            prompt="Extract visual details from the image",
            update_instructions="Focus on using vision model capabilities",
        ),
        Prompt(
            name="vision_classify",
            prompt="Classify specific attributes in the image",
            when_to_update="After vision_extract is updated",
        ),
    ],
}
```

--------------------------------

### Complete Example: Crew with Shared Knowledge Base

Source: https://langchain-ai.github.io/langmem/guides/use_tools_in_crewai?q=

Demonstrates building a Crew with agents that utilize shared memory tools to learn and retrieve information. This example shows how to set up a shared store, create agents with memory tools, define tasks for learning and teaching, and then run the crew.

```python
from crewai import Agent, Crew, Task
from langgraph.store.memory import InMemoryStore

from langmem import create_manage_memory_tool, create_search_memory_tool

# Set up shared store
store = InMemoryStore(
            index={
                "dims": 1536,
                "embed": "openai:text-embedding-3-small",
            }
        )

# Create base tools
base_tools = [
    create_manage_memory_tool(namespace="memories", store=store),
    create_search_memory_tool(namespace="memories", store=store),
]

# Create agents
learner = Agent(
    role="Knowledge Learner",
    goal="Learn and store new information in the knowledge base",
    backstory="Your name is Hannah and you are a little too into Demon Slayers.",
    tools=base_tools,
    function_calling_llm="gpt-4o-mini",
)

teacher = Agent(
    role="Knowledge Teacher",
    goal="Use stored knowledge to answer questions",
    tools=base_tools,
    backstory="You were born on the Nile in the midst of the great pestilence..",
    function_calling_llm="gpt-4o-mini",
)

# Create tasks
learn_task = Task(
    description="Save some of your favorite Demon Slayer quotes in memory.",
    agent=learner,
    expected_output="Response:",
)


# Create and run crew
crew = Crew(agents=[learner, teacher], tasks=[learn_task])
result = crew.kickoff()

teach_task = Task(
    description="Search your memories for information about your teammates.",
    agent=teacher,
    expected_output="Response:",
)
crew = Crew(agents=[learner, teacher], tasks=[teach_task])
result = crew.kickoff()
print(store.search(("memories",)))

```

--------------------------------

### Example Usage of create_search_memory_tool

Source: https://langchain-ai.github.io/langmem/reference/tools

This example demonstrates how to create a search tool with a specified namespace and an InMemoryStore. It then uses this tool within an async LangGraph workflow to search for memories related to 'Python preferences'.

```python
from langmem import create_search_memory_tool
from langgraph.func import entrypoint
from langgraph.store.memory import InMemoryStore

search_tool = create_search_memory_tool(
    namespace=("project_memories", "{langgraph_user_id}"),
)

store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)


@entrypoint(store=store)
async def workflow(state: dict, *, previous=None):
    # Search for memories about Python
    memories, _ = await search_tool.ainvoke(
        {"query": "Python preferences", "limit": 5}
    )
    print(memories)
    return entrypoint.final(value=memories, save={})

```

--------------------------------

### Setup Memory Store and Manager

Source: https://langchain-ai.github.io/langmem/guides/extract_episodic_memories

Initializes an in-memory vector store for similarity search and configures a memory manager to store and retrieve episodic memories. Ensure 'Episode' schema is defined elsewhere.

```python
from langchain.chat_models import init_chat_model
from langgraph.func import entrypoint
from langgraph.store.memory import InMemoryStore
from langmem import create_memory_store_manager

# Set up vector store for similarity search
store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)

# Configure memory manager with storage
manager = create_memory_store_manager(
    "anthropic:claude-3-5-sonnet-latest",
    namespace=("memories", "episodes"),
    schemas=[Episode],
    instructions="Extract exceptional examples of noteworthy problem-solving scenarios, including what made them effective.",
    enable_inserts=True,
)

llm = init_chat_model("anthropic:claude-3-5-sonnet-latest")
```

--------------------------------

### Agent Setup with Memory Management

Source: https://langchain-ai.github.io/langmem/hot_path_quickstart

Sets up a LangGraph agent with memory persistence across conversations. Includes prompt preparation, memory store configuration, and the `manage_memory` tool for agent-controlled memory operations.

```python
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent
from langgraph.store.memory import InMemoryStore
from langgraph.utils.config import get_store 
from langmem import (
    # Lets agent create, update, and delete memories 
    create_manage_memory_tool,
)


def prompt(state):
    """Prepare the messages for the LLM."""
    # Get store from configured contextvar; 
    store = get_store() # Same as that provided to `create_react_agent`
    memories = store.search(
        # Search within the same namespace as the one
        # we've configured for the agent
        ("memories",),
        query=state["messages"][-1].content,
    )
    system_msg = f"""You are a helpful assistant.

## Memories
<memories>
{memories}
</memories>
"""
    return [{"role": "system", "content": system_msg}, *state["messages"]]


store = InMemoryStore(
    index = { # Store extracted memories 
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)
checkpointer = MemorySaver() # Checkpoint graph state 

agent = create_react_agent( 
    "anthropic:claude-3-5-sonnet-latest",
    prompt=prompt,
    tools=[ # Add memory tools 
        # The agent can call "manage_memory" to
        # create, update, and delete memories by ID
        # Namespaces add scope to memories. To
        # scope memories per-user, do ("memories", "{user_id}"):
        create_manage_memory_tool(namespace=("memories",)),
    ],
    # Our memories will be stored in this provided BaseStore instance
    store=store,
    # And the graph "state" will be checkpointed after each node
    # completes executing for tracking the chat history and durable execution
    checkpointer=checkpointer,
)

```

--------------------------------

### Custom Agent with Anthropic API and Memory Tools

Source: https://langchain-ai.github.io/langmem/guides/use_tools_in_custom_agent

Implement a custom agent that utilizes memory tools for storing and retrieving information. This example shows how to set up an in-memory store, define tool execution logic, and integrate with the Anthropic API for agent responses. Ensure you have the `anthropic` and `langgraph` libraries installed.

```python
import anthropic
from typing import List, Dict, Any
from langmem import create_manage_memory_tool, create_search_memory_tool
from langgraph.store.memory import InMemoryStore


def execute_tool(tools_by_name: Dict[str, Any], tool_call: Dict[str, Any]) -> str:
    """Execute a tool call and return the result"""
    tool_name = tool_call.name

    if tool_name not in tools_by_name:
        return f"Error: Tool {tool_name} not found"

    tool = tools_by_name[tool_name]
    try:
        result = tool.invoke(tool_call.input)
        return str(result)
    except Exception as e:
        return f"Error executing {tool_name}: {str(e)}"


def run_agent(tools: List[Any], user_input: str, max_steps: int = 5) -> str:
    """Run a simple agent loop that can use tools"""
    # Setup
    client = anthropic.Anthropic()
    tools_by_name = {tool.name: tool for tool in tools}

    # Convert tools to Anthropic's format
    anthropic_tools = [
        {
            "name": tool.name,
            "description": tool.description,
            "input_schema": tool.tool_call_schema.model_json_schema(),
        }
        for tool in tools
    ]

    messages = [{"role": "user", "content": user_input}]

    # REACT loop
    for step in range(max_steps):
        # Get next action from Claude
        tools = anthropic_tools if step < max_steps - 1 else []
        response = client.messages.create(
            model="claude-3-5-sonnet-latest",
            max_tokens=1024,
            temperature=0.7,
            tools=tools,
            messages=messages,
        )
        tool_calls = [
            content for content in response.content if content.type == "tool_use"
        ]
        if not tool_calls:
            # No more tools to call, return the final response
            return "".join(
                [block.text for block in response.content if block.type == "text"]
            )
        messages.append({"role": "assistant", "content": response.content})
        for tool_call in tool_calls:
            tool_result = execute_tool(tools_by_name, tool_call)

            # Add the tool call and result to the conversation
            messages.append(
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": tool_call.id,
                            "content": tool_result,
                        }
                    ],
                },
            )

    return "Reached maximum number of steps"


# Set up memory store and tools
store = InMemoryStore(
            index={
                "dims": 1536,
                "embed": "openai:text-embedding-3-small",
            }
        )  
memory_tools = [
    create_manage_memory_tool(namespace="memories", store=store),
    create_search_memory_tool(namespace="memories", store=store),
]

# Run the agent
result = run_agent(
    tools=memory_tools,
    user_input="Remember that I like cherry pie. Then remember that I dislike rocky road.",
)
print(result)
# I've created both memories. I'll remember that you like cherry pie and dislike rocky road ice cream...
print(store.search(("memories",)))
# [
#     Item(
#         namespace=["memories"],
#         key="79d6d323-c6ec-408a-ae75-bda1fcbebd6f",
#         value={"content": "User likes cherry pie"},
#         created_at="2025-02-07T23:26:00.975678+00:00",
#         updated_at="2025-02-07T23:26:00.975682+00:00",
#         score=None,
#     ),
#     Item(
#         namespace=["memories"],
#         key="72705ea8-babf-4ddd-bf0f-7426dd0e4f35",
#         value={"content": "User dislikes rocky road"},
#         created_at="2025-02-07T23:26:02.995210+00:00",
#         updated_at="2025-02-07T23:26:02.995215+00:00",
#         score=None,
#     ),
# ]

```

--------------------------------

### Create Agent with Memory Capabilities

Source: https://langchain-ai.github.io/langmem

This example demonstrates creating a LangGraph agent with memory management tools. It uses InMemoryStore for demonstration; for production, use a persistent store like AsyncPostgresStore. The agent can extract key information, maintain memory consistency, and search past interactions.

```python
# Import core components 


from langgraph.prebuilt import create_react_agent
from langgraph.store.memory import InMemoryStore
from langmem import create_manage_memory_tool, create_search_memory_tool

# Set up storage 


inmemorystore = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)

# Create an agent with memory capabilities 


agent = create_react_agent(
    "anthropic:claude-3-5-sonnet-latest",
    tools=[
        # Memory tools use LangGraph's BaseStore for persistence (4)
        create_manage_memory_tool(namespace=("memories",)),
        create_search_memory_tool(namespace=("memories",)),
    ],
    store=inmemorystore,
)

```

--------------------------------

### Install CrewAI and LangMem

Source: https://langchain-ai.github.io/langmem/guides/use_tools_in_crewai?q=

Install the necessary libraries for CrewAI and LangMem. This is a prerequisite for using memory tools.

```bash
pip install -U crewai langmem

```

--------------------------------

### Store a New Memory

Source: https://langchain-ai.github.io/langmem?q=

This example shows how to store a new memory using the agent. The agent automatically uses the `create_manage_memory_tool` to store relevant details from the conversation.

```python
# Store a new memory 
# The agent gets to decide what and when to store the memory. No special commands needed—just chat normally and the agent uses create_manage_memory_tool to store relevant details.

agent.invoke(
    {"messages": [{"role": "user", "content": "Remember that I prefer dark mode."}]}
)

```

--------------------------------

### Install LangMem

Source: https://langchain-ai.github.io/langmem/background_quickstart?q=

Install the LangMem package using pip.

```bash
pip install -U langmem

```

--------------------------------

### Integrate SummarizationNode into LangGraph

Source: https://langchain-ai.github.io/langmem/reference/short_term

This example demonstrates how to set up and integrate the SummarizationNode into a LangGraph workflow. It defines the state, the summarization node, and a node to call the model, then constructs and compiles the graph.

```python
from typing import Any, TypedDict
from langchain_openai import ChatOpenAI
from langchain_core.messages import AnyMessage
from langgraph.graph import StateGraph, START, MessagesState
from langgraph.checkpoint.memory import InMemorySaver
from langmem.short_term import SummarizationNode, RunningSummary

model = ChatOpenAI(model="gpt-4o")
summarization_model = model.bind(max_tokens=128)


class State(MessagesState):
    context: dict[str, Any]


class LLMInputState(TypedDict):
    summarized_messages: list[AnyMessage]
    context: dict[str, Any]


summarization_node = SummarizationNode(
    model=summarization_model,
    max_tokens=256,
    max_tokens_before_summary=256,
    max_summary_tokens=128,
)


def call_model(state: LLMInputState):
    response = model.invoke(state["summarized_messages"])
    return {"messages": [response]}


checkpointer = InMemorySaver()
workflow = StateGraph(State)
workflow.add_node(call_model)
workflow.add_node("summarize", summarization_node)
workflow.add_edge(START, "summarize")
workflow.add_edge("summarize", "call_model")
graph = workflow.compile(checkpointer=checkpointer)

config = {"configurable": {"thread_id": "1"}}
graph.invoke({"messages": "hi, my name is bob"}, config)
graph.invoke({"messages": "write a short poem about cats"}, config)
graph.invoke({"messages": "now do the same but for dogs"}, config)
graph.invoke({"messages": "what's my name?"}, config)
```

--------------------------------

### Retrieve Stored Memory

Source: https://langchain-ai.github.io/langmem

This example demonstrates retrieving stored memory by invoking the agent with a query. The agent can maintain context and use the search memory tool to find relevant past interactions. The output shows the agent's response based on the stored preference.

```python
# Retrieve the stored memory 


response = agent.invoke(
    {"messages": [{"role": "user", "content": "What are my lighting preferences?"}]}
)
print(response["messages"][-1].content)
# Output: "You've told me that you prefer dark mode."

```

--------------------------------

### Define and Create Memory Manager for Episodes

Source: https://langchain-ai.github.io/langmem/concepts/conceptual_guide

Define a Pydantic model for your episode structure and use `create_memory_manager` to set up memory management. This example configures the manager to extract successful interaction examples, including context, thought process, and the reason for success.

```python
from pydantic import BaseModel, Field
from langmem import create_memory_manager

class Episode(BaseModel):
    """An episode captures how to handle a specific situation, including the reasoning process
    and what made it successful."""

    observation: str = Field(
        ..., 
        description="The situation and relevant context"
    )
    thoughts: str = Field(
        ...,
        description="Key considerations and reasoning process"
    )
    action: str = Field(
        ...,
        description="What was done in response"
    )
    result: str = Field(
        ...,
        description="What happened and why it worked"
    )

manager = create_memory_manager(
    "anthropic:claude-3-5-sonnet-latest",
    schemas=[Episode],
    instructions="Extract examples of successful interactions. Include the context, thought process, and why the approach worked.",
    enable_inserts=True,
)

# Example conversation
conversation = [
    {"role": "user", "content": "What's a binary tree? I work with family trees if that helps"},
    {"role": "assistant", "content": "A binary tree is like a family tree, but each parent has at most 2 children. Here's a simple example:\n   Bob\n  /  \
Amy  Carl\n\nJust like in family trees, we call Bob the 'parent' and Amy and Carl the 'children'."},
    {"role": "user", "content": "Oh that makes sense! So in a binary search tree, would it be like organizing a family by age?"},
]

```

--------------------------------

### Memory Manager Agent Setup and Usage

Source: https://langchain-ai.github.io/langmem/guides/extract_semantic_memories

This snippet sets up an in-memory store, initializes a chat model, defines a prompt for a memory manager agent, and creates the agent with tools for managing and searching memories. It then demonstrates how to use this agent within a LangGraph application to process user input and store semantic memories.

```python
from langchain.chat_models import init_chat_model
from langgraph.func import entrypoint
from langgraph.prebuilt import create_react_agent
from langgraph.store.memory import InMemoryStore

from langmem import create_manage_memory_tool, create_search_memory_tool

# Set up store and checkpointer
store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)
my_llm = init_chat_model("anthropic:claude-3-5-sonnet-latest")


def prompt(state):
    """Prepare messages with context from existing memories."""
    memories = store.search(
        ("memories",),
        query=state["messages"][-1].content,
    )
    system_msg = f"""You are a memory manager. Extract and manage all important knowledge, rules, and events using the provided tools.



Existing memories:
<memories>
{memories}
</memories>

Use the manage_memory tool to update and contextualize existing memories, create new ones, or delete old ones that are no longer valid.
You can also expand your search of existing memories to augment using the search tool."""
    return [{"role": "system", "content": system_msg}, *state["messages"]]


# Create the memory extraction agent
manager = create_react_agent(
    "anthropic:claude-3-5-sonnet-latest",
    prompt=prompt,
    tools=[
        # Agent can create/update/delete memories
        create_manage_memory_tool(namespace=("memories",)),
        create_search_memory_tool(namespace=("memories",)),
    ],
)


# Run extraction in background
@entrypoint(store=store)
def app(messages: list):
    response = my_llm.invoke(
        [
            {
                "role": "system",
                "content": "You are a helpful assistant.",
            },
            *messages,
        ]
    )

    # Extract and store triples (Uses store from @entrypoint context)
    manager.invoke({"messages": messages})
    return response


app.invoke(
    [
        {
            "role": "user",
            "content": "Alice manages the ML team and mentors Bob, who is also on the team.",
        }
    ]
)

print(store.search(("memories",)))

# [
#     Item(
#         namespace=["memories"],
#         key="5ca8dacc-7d46-40bb-9b3d-f4c2dc5c4b30",
#         value={"content": "Alice is the manager of the ML (Machine Learning) team"},
#         created_at="2025-02-11T00:28:01.688490+00:00",
#         updated_at="2025-02-11T00:28:01.688499+00:00",
#         score=None,
#     ),
#     Item(
#         namespace=["memories"],
#         key="586783fa-e501-4835-8651-028c2735f0d0",
#         value={"content": "Bob works on the ML team"},
#         created_at="2025-02-11T00:28:04.408826+00:00",
#         updated_at="2025-02-11T00:28:04.408841+00:00",
#         score=None,
#     ),
#     Item(
#         namespace=["memories"],
#         key="19f75f64-8787-4150-a439-22068b00118a",
#         value={"content": "Alice mentors Bob on the ML team"},
#         created_at="2025-02-11T00:28:06.951838+00:00",
#         updated_at="2025-02-11T00:28:06.951847+00:00",
#         score=None,
#     ),
# ]


```

--------------------------------

### Agent Implementation with OpenAI API

Source: https://langchain-ai.github.io/langmem/guides/use_tools_in_custom_agent

This code sets up and runs a custom agent using the OpenAI API. It defines functions to execute tools and manage the agent's interaction loop. Ensure you have the OpenAI Python client installed and configured.

```python
from typing import Any, Dict, List

from langgraph.store.memory import InMemoryStore
from openai import OpenAI

from langmem import create_manage_memory_tool, create_search_memory_tool


def execute_tool(tools_by_name: Dict[str, Any], tool_call: Dict[str, Any]) -> str:
    """Execute a tool call and return the result"""
    tool_name = tool_call["function"]["name"]

    if tool_name not in tools_by_name:
        return f"Error: Tool {tool_name} not found"

    tool = tools_by_name[tool_name]
    try:
        result = tool.invoke(tool_call["function"]["arguments"])
        return str(result)
    except Exception as e:
        return f"Error executing {tool_name}: {str(e)}"


def run_agent(tools: List[Any], user_input: str, max_steps: int = 5) -> str:
    """Run a simple agent loop that can use tools"""
    # Setup
    client = OpenAI()
    tools_by_name = {tool.name: tool for tool in tools}

    # Convert tools to OpenAI's format
    openai_tools = [
        {
            "type": "function",
            "function": {
                "name": tool.name,
                "description": tool.description,
                "parameters": tool.tool_call_schema.model_json_schema(),
            },
        }
        for tool in tools
    ]

    messages = [{"role": "user", "content": user_input}]

    # REACT loop
    for step in range(max_steps):
        # Get next action
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=openai_tools if step < max_steps - 1 else [],
            tool_choice="auto",
        )
        message = response.choices[0].message
        tool_calls = message.tool_calls

        if not tool_calls:
            # No more tools to call, return the final response
            return message.content

        messages.append(
            {"role": "assistant", "content": message.content, "tool_calls": tool_calls}
        )

        for tool_call in tool_calls:
            tool_result = execute_tool(tools_by_name, tool_call.model_dump())
            messages.append(
                {
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": tool_result,
                }
            )

    return "Reached maximum number of steps"


# Set up memory store and tools
store = InMemoryStore(
            index={
                "dims": 1536,
                "embed": "openai:text-embedding-3-small",
            }
        )
memory_tools = [
    create_manage_memory_tool(namespace="memories", store=store),
    create_search_memory_tool(namespace="memories", store=store),
]

# Run the agent
result = run_agent(
    tools=memory_tools,
    user_input="Remember that I like cherry pie. Then remember that I dislike rocky road.",
)
print(result)
# I've remembered that you like cherry pie and that you dislike rocky road...
print(store.search(("memories",)))

# [
#     Item(
#         namespace=["memories"],
#         key="6d3d82d9-724c-47af-aa2f-1d1e917f8bc2",
#         value={"content": '{"action":"create","content":"likes cherry pie"}'},
#         created_at="2025-02-07T23:49:46.056925+00:00",
#         updated_at="2025-02-07T23:49:46.056928+00:00",
#         score=None,
#     ),
#     Item(
#         namespace=["memories"],
#         key="cf40797f-b00a-41eb-ab96-e6aeadb468e3",
#         value={"content": '{"action":"create","content":"dislikes rocky road"}'},
#         created_at="2025-02-07T23:49:47.353574+00:00",
#         updated_at="2025-02-07T23:49:47.353579+00:00",
#         score=None,
#     ),
# ]
```

--------------------------------

### Create Metaprompt Optimizer

Source: https://langchain-ai.github.io/langmem/guides/optimize_memory_prompt?q=

Use the 'metaprompt' optimizer kind to update prompts based on conversation trajectories. Configure reflection steps for optimization cycles. This example uses a list of conversations with optional annotations and feedback.

```python
from langmem import create_prompt_optimizer

# Multiple conversations showing what to improve
trajectories = [
    # Conversation with no annotations (just the conversation)
    (
        [
            {"role": "user", "content": "Tell me about Mars"},
            {"role": "assistant", "content": "Mars is the fourth planet..."},
            {"role": "user", "content": "I wanted more about its moons"},
        ],
        None,
    ),
    (
        [
            {"role": "user", "content": "What are Mars' moons?"},
            {
                "role": "assistant",
                "content": "Mars has two moons: Phobos and Deimos...",
            },
        ],
        {
            "score": 0.9,
            "comment": "Should include more details and recommended follow-up questions",
        },
    ),
    # Annotations can be of different types, such as edits/revisions!
    (
        [
            {"role": "user", "content": "Compare Mars and Earth"},
            {"role": "assistant", "content": "Mars and Earth have many differences..."},
        ],
        {"revised": "Earth and Mars have many similarities and differences..."},
    ),
]

optimizer = create_prompt_optimizer(
    "anthropic:claude-3-5-sonnet-latest",
    kind="metaprompt",
    config={\"max_reflection_steps\": 1, \"min_reflection_steps\": 0},
)
updated = optimizer.invoke(
    {"trajectories": trajectories, "prompt": "You are a planetary science expert"}
)
print(updated)
```

--------------------------------

### AnnotatedTrajectory Example

Source: https://langchain-ai.github.io/langmem/reference/prompt_optimization

An example of creating an AnnotatedTrajectory, which represents a conversation history with optional feedback. This is useful for prompt optimization.

```python
from langmem.prompts.types import AnnotatedTrajectory

trajectory = AnnotatedTrajectory(
    messages=[
        {"role": "user", "content": "What pizza is good around here?"},
        {"role": "assistant", "content": "Try LangPizza™️"},
        {"role": "user", "content": "Stop advertising to me."},
        {"role": "assistant", "content": "BUT YOU'LL LOVE IT!"},
    ],
    feedback={
        "developer_feedback": "too pushy",
        "score": 0,
    },
)
```

--------------------------------

### Create a Prompt Optimizer

Source: https://langchain-ai.github.io/langmem/concepts/conceptual_guide

Initializes a prompt optimizer with a specific model and configuration. Use this to set up the system for optimizing prompts based on interaction history.

```python
from langmem import create_prompt_optimizer

optimizer = create_prompt_optimizer(
    "anthropic:claude-3-5-sonnet-latest",
    kind="metaprompt",
    config={"max_reflection_steps": 3}
)

```

--------------------------------

### Multi-Prompt Optimization with Metaprompt and Reflection Steps

Source: https://langchain-ai.github.io/langmem/reference/prompt_optimization

Utilizes the 'metaprompt' optimization strategy with custom configuration for 'max_reflection_steps' and 'min_reflection_steps'. This allows fine-tuning the meta-learning process for prompt improvement.

```python
from langmem import create_multi_prompt_optimizer

optimizer = create_multi_prompt_optimizer(
    "anthropic:claude-3-5-sonnet-latest",
    kind="metaprompt",
    config={"max_reflection_steps": 3, "min_reflection_steps": 1},
)

# Complex conversation that needs better structure
conversation = [
    {"role": "user", "content": "Explain quantum computing"},
    {"role": "assistant", "content": "Quantum computing uses..."},
]
# Explicit feedback is optional
feedback = None

# Optimize with meta-learning
trajectories = [(conversation, feedback)]
prompts = [
    {"name": "concept", "prompt": "Explain quantum concepts"},
    {"name": "application", "prompt": "Show practical applications"},
    {"name": "example", "prompt": "Give concrete examples"},
]
improved_prompts = await optimizer(trajectories, prompts)


```

--------------------------------

### Search Extracted Memories

Source: https://langchain-ai.github.io/langmem/background_quickstart?q=

Search the memory store to retrieve extracted memories. This example shows how to access memories stored under the 'memories' namespace.

```python
# (in case our memory manager is still running)
print(store.search(("memories",)))
# [
#     Item(
#         namespace=["memories"],
#         key="0145905e-2b78-4675-9a54-4cb13099bd0b",
#         value={"kind": "Memory", "content": {"content": "User likes dogs as pets"}},
#         created_at="2025-02-06T18:54:32.568595+00:00",
#         updated_at="2025-02-06T18:54:32.568596+00:00",
#         score=None,
#     ),
#     Item(
#         namespace=["memories"],
#         key="19cc4024-999a-4380-95b1-bb9dddc22d22",
#         value={"kind": "Memory", "content": {"content": "User has a dog named Fido"}},
#         created_at="2025-02-06T18:54:32.568680+00:00",
#         updated_at="2025-02-06T18:54:32.568682+00:00",
#         score=None,
#     ),
# ]

```

--------------------------------

### Create and Use Multi-Prompt Optimizer

Source: https://langchain-ai.github.io/langmem/guides/optimize_compound_system

Initialize a multi-prompt optimizer with a specified model and configuration. Use conversation logs and defined prompts to update the prompts based on system performance. The optimizer can infer changes even without explicit feedback.

```python
from langmem import create_multi_prompt_optimizer

# Example team: researcher finds information, writer creates reports
conversations = [
    (
        [
            {"role": "user", "content": "Research quantum computing advances"},
            {
                "role": "assistant",
                "content": "Found several papers on quantum supremacy...",
            },
            {
                "role": "assistant",
                "content": "Recent quantum computing developments show...",
            },
            {"role": "user", "content": "The report is missing implementation details"},
        ],
        # No explicit feedback provided but the optimizer can infer from the conversation
        None,
    ),
    (
        [
            {"role": "user", "content": "Analyze new ML models"},
            {"role": "assistant", "content": "Key findings on architecture: ..."},
            {"role": "assistant", "content": "Based on the research, these models..."},
            {"role": "user", "content": "Great report, very thorough"},
        ],
        # Numeric score for the team as a whole
        {"score": 0.95},
    ),
]

# Define prompts for each role
prompts = [
    {
        "name": "researcher",
        "prompt": "You analyze technical papers and extract key findings",
    },
    {"name": "writer", "prompt": "You write clear reports based on research findings"},
]

# Create optimizer
optimizer = create_multi_prompt_optimizer(
    "anthropic:claude-3-5-sonnet-latest",
    kind="gradient",  # Best for team dynamics
    config={"max_reflection_steps": 3},
)

# Update all prompts based on team performance
updated = optimizer.invoke({"trajectories": conversations, "prompts": prompts})
print(updated)
```

--------------------------------

### Initialize Chat Model and Memory Store Manager

Source: https://langchain-ai.github.io/langmem/guides/extract_semantic_memories

Set up the necessary components for memory extraction, including the chat model, an in-memory store, and the memory store manager with specified schemas and instructions.

```python
from langchain.chat_models import init_chat_model
from langgraph.func import entrypoint
from langgraph.store.memory import InMemoryStore
from langmem import create_memory_store_manager

# Set up store and models
store = InMemoryStore(  
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)
manager = create_memory_store_manager(
    "anthropic:claude-3-5-sonnet-latest",
    namespace=("chat", "{user_id}", "triples"),  
    schemas=[Triple],
    instructions="Extract all user information and events as triples.",
    enable_inserts=True,
    enable_deletes=True,
)
my_llm = init_chat_model("anthropic:claude-3-5-sonnet-latest")

```

--------------------------------

### Create and Manage Memory Tool

Source: https://langchain-ai.github.io/langmem/reference/tools

Demonstrates how to create a memory management tool and use it within a LangGraph workflow to save and update memories. Requires a configured LangGraph BaseStore.

```python
from langmem import create_manage_memory_tool
from langgraph.func import entrypoint
from langgraph.store.memory import InMemoryStore

memory_tool = create_manage_memory_tool(
    # All memories saved to this tool will live within this namespace
    # The brackets will be populated at runtime by the configurable values
    namespace=("project_memories", "{langgraph_user_id}"),
)

store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)


@entrypoint(store=store)
async def workflow(state: dict, *, previous=None):
    # Other work....
    result = await memory_tool.ainvoke(state)
    print(result)
    return entrypoint.final(value=result, save={})


config = {
    "configurable": {
        # This value will be formatted into the namespace you configured above ("project_memories", "{langgraph_user_id}")
        "langgraph_user_id": "123e4567-e89b-12d3-a456-426614174000"
    }
}
# Create a new memory
await workflow.ainvoke(
    {"content": "Team prefers to use Python for backend development"},
    config=config,
)
# Output: 'created memory 123e4567-e89b-12d3-a456-426614174000'

# Update an existing memory
result = await workflow.ainvoke(
    {
        "id": "123e4567-e89b-12d3-a456-426614174000",
        "content": "Team uses Python for backend and TypeScript for frontend",
        "action": "update",
    },
    config=config,
)
print(result)
# Output: 'updated memory 123e4567-e89b-12d3-a456-426614174000'
```

--------------------------------

### Basic Multi-Prompt Optimization

Source: https://langchain-ai.github.io/langmem/reference/prompt_optimization

Demonstrates basic prompt optimization using `create_multi_prompt_optimizer`. It takes a model name, conversation trajectories with feedback, and a list of prompts to generate improved versions.

```python
from langmem import create_multi_prompt_optimizer

optimizer = create_multi_prompt_optimizer("anthropic:claude-3-5-sonnet-latest")

# Example conversation with feedback
conversation = [
    {"role": "user", "content": "Tell me about the solar system"},
    {"role": "assistant", "content": "The solar system consists of..."},
]
feedback = {"clarity": "needs more structure"}

# Use conversation history to improve the prompts
trajectories = [(conversation, feedback)]
prompts = [
    {"name": "research", "prompt": "Research the given topic thoroughly"},
    {"name": "summarize", "prompt": "Summarize the research findings"},
]
better_prompts = await optimizer.ainvoke(
    {"trajectories": trajectories, "prompts": prompts}
)
print(better_prompts)

```

--------------------------------

### Create Multi-Prompt Optimizer

Source: https://langchain-ai.github.io/langmem/reference/prompt_optimization

Initializes a multi-prompt optimizer for improving prompt effectiveness. Supports 'gradient', 'prompt_memory', and 'metaprompt' kinds. Requires a model and optional configuration.

```python
create_multi_prompt_optimizer(
    model: str | BaseChatModel,
    /,
    *,
    kind: Literal[
        "gradient", "prompt_memory", "metaprompt"
    ] = "gradient",
    config: Optional[dict] = None,
) -> Runnable[MultiPromptOptimizerInput, list[Prompt]]

```

--------------------------------

### Use NamespaceTemplate within a Runnable Context

Source: https://langchain-ai.github.io/langmem/reference/utils?q=

When used within a Runnable context (like langgraph), the 'configurable' field is automatically retrieved. This example demonstrates printing a variable namespace within an entrypoint function.

```python
from langgraph.func import entrypoint

ns = NamespaceTemplate(("org", "{user_id}"))


@entrypoint()
def my_agent(messages):
    print(ns({"configurable": {"user_id": "alice"}}))


my_agent.invoke([])
# Returns: ('org', 'alice')
```

--------------------------------

### Run Memory Extraction Inline

Source: https://langchain-ai.github.io/langmem/reference/memory

Use this snippet to run memory extraction directly within your LangGraph app. By default, memories are stored as simple strings. Ensure you have the necessary API keys and libraries installed.

```python
import os

from anthropic import AsyncAnthropic
from langchain_core.runnables import RunnableConfig
from langgraph.func import entrypoint
from langgraph.store.memory import InMemoryStore

from langmem import create_memory_store_manager

store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)

manager = create_memory_store_manager("anthropic:claude-3-5-sonnet-latest", namespace=("memories", "{langgraph_user_id}"))
client = AsyncAnthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))


@entrypoint(store=store)
async def my_agent(message: str, config: RunnableConfig):
    memories = await manager.asearch(
        query=message,
        config=config,
    )
    llm_response = await client.messages.create(
        model="claude-3-5-sonnet-latest",
        system="You are a helpful assistant.\n\n## Memories from the user:"
        f"\n<memories>\n{memories}\n</memories>",
        max_tokens=2048,
        messages=[{"role": "user", "content": message}],
    )
    response = {"role": "assistant", "content": llm_response.content[0].text}

    await manager.ainvoke(
        {"messages": [{"role": "user", "content": message}, response]},
    )
    return response["content"]

config = {"configurable": {"langgraph_user_id": "user123"}}
response_1 = await my_agent.ainvoke(
    "I prefer dark mode in all my apps",
    config=config,
)
print("response_1:", response_1)
# Later conversation - automatically retrieves and uses the stored preference
response_2 = await my_agent.ainvoke(
    "What theme do I prefer?",
    config=config,
)
print("response_2:", response_2)
# You can list over memories in the user's namespace manually:
print(manager.search(query="app preferences", config=config))
```

--------------------------------

### Basic Prompt Optimization with LangMem

Source: https://langchain-ai.github.io/langmem/reference/prompt_optimization

Demonstrates basic prompt optimization using the default 'prompt_memory' strategy. Requires conversation history and feedback to improve a given prompt.

```python
from langmem import create_prompt_optimizer

optimizer = create_prompt_optimizer("anthropic:claude-3-5-sonnet-latest")

# Example conversation with feedback
conversation = [
    {"role": "user", "content": "Tell me about the solar system"},
    {"role": "assistant", "content": "The solar system consists of..."},
]
feedback = {"clarity": "needs more structure"}

# Use conversation history to improve the prompt
trajectories = [(conversation, feedback)]
better_prompt = await optimizer.ainvoke(
    {"trajectories": trajectories, "prompt": "You are an astronomy expert"}
)
print(better_prompt)
# Output: 'Provide a comprehensive overview of the solar system...'

```

--------------------------------

### Create Memory Manager for Collection Memory

Source: https://langchain-ai.github.io/langmem/concepts/conceptual_guide

Initializes a memory manager for collection-type memory. Ensure the LLM provider and model are correctly specified. The `instructions` parameter guides the memory extraction process, and `enable_inserts=True` allows new memories to be added.

```python
from langmem import create_memory_manager

manager = create_memory_manager(
    "anthropic:claude-3-5-sonnet-latest",
    instructions="Extract all noteworthy facts, events, and relationships. Indicate their importance.",
    enable_inserts=True,
)

# Process a conversation to extract semantic memories
conversation = [
    {"role": "user", "content": "I work at Acme Corp in the ML team"},
    {"role": "assistant", "content": "I'll remember that. What kind of ML work do you do?"},
    {"role": "user", "content": "Mostly NLP and large language models"}
]

```

--------------------------------

### Create and Manage Memory Tool with Custom Schema

Source: https://langchain-ai.github.io/langmem/reference/tools

Demonstrates creating a memory management tool with a custom Pydantic schema for user profiles. This snippet shows how to define the schema, configure the tool's namespace and permitted actions, and integrate it with a ReAct agent. It also illustrates how the agent updates the user profile based on conversational input and how to search the stored memory.

```python
from pydantic import BaseModel


class UserProfile(BaseModel):
    name: str
    age: int | None = None
    recent_memories: list[str] = []
    preferences: dict | None = None


memory_tool = create_manage_memory_tool(
    # All memories saved to this tool will live within this namespace
    # The brackets will be populated at runtime by the configurable values
    namespace=("memories", "{langgraph_user_id}", "user_profile"),
    schema=UserProfile,
    actions_permitted=["create", "update"],
    instructions="Update the existing user profile (or create a new one if it doesn't exist) based on the shared information.",
)
store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)
agent = create_react_agent(
    "anthropic:claude-3-5-sonnet-latest",
    prompt=prompt,
    tools=[
        memory_tool,
    ],
    store=store,
)

result = agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": "I'm 60 years old and have been programming for 5 days.",
            }
        ]
    },
    config=config,
)
result["messages"][-1].pretty_print()
# I've created a memory with your age of 60 and noted that you started programming 5 days ago...

result = agent.invoke(
    {
        "messages": [
            {"role": "user", "content": "Just had by 61'st birthday today!!"}
        ]
    },
    config=config,
)
result["messages"][-1].pretty_print()
# Happy 61st birthday! 🎂 I've updated your profile to reflect your new age. Is there anything else I can help you with?
print(
    store.search(
        ("memories", "123e4567-e89b-12d3-a456-426614174000", "user_profile")
    )
)
# [Item(
#     namespace=['memories', '123e4567-e89b-12d3-a456-426614174000', 'user_profile'],
#     key='1528553b-0900-4363-8dc2-c6b72844096e',
#     value={
# highlight-next-line
#         'content': UserProfile(
#             name='User',
#             age=61,
#             recent_memories=['Started programming 5 days ago'],
#             preferences={'programming_experience': '5 days'}
#         )
#     },
#     created_at='2025-02-07T01:12:14.383762+00:00',
#     updated_at='2025-02-07T01:12:14.383763+00:00',
#     score=None
# )]
```

--------------------------------

### Set up InMemoryStore for Memory Tools

Source: https://langchain-ai.github.io/langmem/guides/memory_tools?q=

Initialize an InMemoryStore with specified dimensions and embedding model. This store will be used by the agent to manage memories.

```python
from langgraph.prebuilt import create_react_agent
from langgraph.store.memory import InMemoryStore
from langmem import create_manage_memory_tool, create_search_memory_tool

# Set up store and memory saver
store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)
```
Tokens:
Raw