Use memory client's built-in LangChain/LangGraph integration

Updated 04_memory_tools to use the new integration:
- Use create_memory_client() async factory
- Use get_memory_tools() to get LangChain StructuredTool objects
- No manual wrapping needed - tools are ready to use
- Simplified code significantly

The memory client now provides first-class LangChain/LangGraph support\!

Author: abrookins

python-recipes/context-engineering/notebooks/section-3-memory/04_memory_tools.ipynb

@@ -129,23 +129,18 @@
         "from langchain_openai import ChatOpenAI\n",
         "from langchain_openai import ChatOpenAI\n",
         "from langchain_core.messages import SystemMessage, HumanMessage, AIMessage, ToolMessage\n",
-        "from langchain_core.tools import tool\n",
-        "from typing import List, Optional\n",
-        "from agent_memory_client import MemoryAPIClient as MemoryClient, MemoryClientConfig\n",
-        "import json\n",
+        "from agent_memory_client import create_memory_client\n",
+        "from agent_memory_client.integrations.langchain import get_memory_tools\n",
         "import asyncio\n",
+        "import os\n",
         "\n",
         "# Initialize\n",
         "student_id = \"student_memory_tools\"\n",
         "session_id = \"tool_demo\"\n",
         "\n",
-        "# Initialize memory client with proper config\n",
-        "import os\n",
-        "config = MemoryClientConfig(\n",
-        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8000\"),\n",
-        "    default_namespace=\"redis_university\"\n",
-        ")\n",
-        "memory_client = MemoryClient(config=config)\n",
+        "# Initialize memory client using the new async factory\n",
+        "base_url = os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8000\")\n",
+        "memory_client = await create_memory_client(base_url)\n",
         "\n",
         "llm = ChatOpenAI(model=\"gpt-4o\", temperature=0.7)\n",
         "\n",
@@ -165,9 +160,9 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Getting Memory Tools from the Client\n",
+        "### Getting Memory Tools with LangChain Integration\n",
         "\n",
-        "The memory client provides built-in tool schemas that are ready to use with LLMs. You don't need to manually define tools - the client handles this for you!"
+        "The memory client now has built-in LangChain/LangGraph integration! Just call `get_memory_tools()` and you get ready-to-use LangChain tools."
       ]
     },
     {
@@ -176,67 +171,33 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Get all memory tool schemas from the client\n",
-        "# The memory client provides OpenAI-format tool schemas\n",
-        "memory_tool_schemas = memory_client.get_all_memory_tool_schemas()\n",
-        "\n",
-        "print(\"Available memory tools from client:\")\n",
-        "for tool_schema in memory_tool_schemas:\n",
-        "    print(f\"  - {tool_schema['function']['name']}: {tool_schema['function']['description'][:80]}...\")\n",
+        "# Get LangChain-compatible memory tools from the client\n",
+        "# This returns a list of StructuredTool objects ready to use with LangChain/LangGraph\n",
+        "memory_tools = get_memory_tools(\n",
+        "    memory_client=memory_client,\n",
+        "    session_id=session_id,\n",
+        "    user_id=student_id\n",
+        ")\n",
         "\n",
-        "# Create LangChain tools that wrap the memory client's resolve_function_call\n",
-        "# This allows us to use LangChain's tool calling while leveraging the client's built-in tools\n",
+        "print(\"Available memory tools:\")\n",
+        "for tool in memory_tools:\n",
+        "    print(f\"  - {tool.name}: {tool.description[:80]}...\")\n",
         "\n",
-        "@tool\n",
-        "async def create_long_term_memory(memories: List[dict]) -> str:\n",
-        "    \"\"\"\n",
-        "    Store important information in long-term memory.\n",
-        "    \n",
-        "    Args:\n",
-        "        memories: List of memory objects with 'text', 'memory_type', 'topics', and 'entities'\n",
-        "    \n",
-        "    Use this when students share preferences, goals, or important facts.\n",
-        "    \"\"\"\n",
-        "    result = await memory_client.resolve_function_call(\n",
-        "        function_name=\"create_long_term_memory\",\n",
-        "        args={\"memories\": memories},\n",
-        "        session_id=session_id,\n",
-        "        user_id=student_id\n",
-        "    )\n",
-        "    return f\"✅ Stored {len(memories)} memory(ies): {result}\"\n",
-        "\n",
-        "@tool\n",
-        "async def search_long_term_memory(text: str, limit: int = 5) -> str:\n",
-        "    \"\"\"\n",
-        "    Search for relevant memories using semantic search.\n",
-        "    \n",
-        "    Args:\n",
-        "        text: What to search for in memories\n",
-        "        limit: Maximum number of memories to retrieve (default: 5)\n",
-        "    \n",
-        "    Use this when you need to recall information about the student.\n",
-        "    \"\"\"\n",
-        "    result = await memory_client.resolve_function_call(\n",
-        "        function_name=\"search_long_term_memory\",\n",
-        "        args={\"text\": text, \"limit\": limit},\n",
-        "        session_id=session_id,\n",
-        "        user_id=student_id\n",
-        "    )\n",
-        "    return str(result)\n",
-        "\n",
-        "print(\"\\n✅ LangChain tools created that wrap memory client's built-in tools\")"
+        "print(f\"\\n✅ Got {len(memory_tools)} LangChain tools from memory client\")"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Key Insight: Wrapping the Memory Client\n",
+        "### Key Insight: Built-in LangChain Integration\n",
         "\n",
-        "Our LangChain tools are thin wrappers around `memory_client.resolve_function_call()`. This gives us:\n",
-        "- LangChain's tool calling interface (familiar to LangGraph users)\n",
-        "- Memory client's built-in tool implementations (no need to reimplement)\n",
-        "- Best of both worlds!"
+        "The `get_memory_tools()` function returns LangChain `StructuredTool` objects that:\n",
+        "- Work seamlessly with LangChain's `llm.bind_tools()` and LangGraph agents\n",
+        "- Handle all the memory client API calls internally\n",
+        "- Are pre-configured with your session_id and user_id\n",
+        "\n",
+        "No manual wrapping needed - just use them like any other LangChain tool!"
       ]
     },
     {
@@ -254,8 +215,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Configure agent with our LangChain memory tools\n",
-        "memory_tools = [create_long_term_memory, search_long_term_memory]\n",
+        "# Configure agent with memory tools\n",
         "llm_with_tools = llm.bind_tools(memory_tools)\n",
         "\n",
         "system_prompt = \"\"\"You are a class scheduling agent for Redis University.\n",
@@ -310,15 +270,16 @@
         "        print(f\"   Tool: {tool_call['name']}\")\n",
         "        print(f\"   Args: {tool_call['args']}\")\n",
         "        \n",
-        "        # Execute the tool (LangChain handles calling our wrapped function)\n",
-        "        if tool_call['name'] == 'create_long_term_memory':\n",
-        "            result = await create_long_term_memory.ainvoke(tool_call['args'])\n",
+        "        # Find and execute the tool\n",
+        "        tool = next((t for t in memory_tools if t.name == tool_call['name']), None)\n",
+        "        if tool:\n",
+        "            result = await tool.ainvoke(tool_call['args'])\n",
         "            print(f\"   Result: {result}\")\n",
         "            \n",
         "            # Add tool result to messages\n",
         "            messages.append(response)\n",
         "            messages.append(ToolMessage(\n",
-        "                content=result,\n",
+        "                content=str(result),\n",
         "                tool_call_id=tool_call['id']\n",
         "            ))\n",
         "    \n",
@@ -370,16 +331,17 @@
         "        print(f\"   Tool: {tool_call['name']}\")\n",
         "        print(f\"   Args: {tool_call['args']}\")\n",
         "        \n",
-        "        # Execute the tool\n",
-        "        if tool_call['name'] == 'search_long_term_memory':\n",
-        "            result = await search_long_term_memory.ainvoke(tool_call['args'])\n",
+        "        # Find and execute the tool\n",
+        "        tool = next((t for t in memory_tools if t.name == tool_call['name']), None)\n",
+        "        if tool:\n",
+        "            result = await tool.ainvoke(tool_call['args'])\n",
         "            print(f\"\\n   Retrieved memories:\")\n",
         "            print(f\"   {result}\")\n",
         "            \n",
         "            # Add tool result to messages\n",
         "            messages.append(response)\n",
         "            messages.append(ToolMessage(\n",
-        "                content=result,\n",
+        "                content=str(result),\n",
         "                tool_call_id=tool_call['id']\n",
         "            ))\n",
         "    \n",