style(examples): clean up unused imports and type ignores

Author: david-mamani

docs/langgraph_integration.md

@@ -1,79 +1,97 @@
-# LangGraph Integration
+# MemU LangGraph Integration
 
-This integration provides a seamless way to use MemU's long-term memory capabilities within LangGraph and LangChain agents.
+The MemU LangGraph Integration provides a seamless adapter to expose MemU's powerful memory capabilities (`memorize` and `retrieve`) as standard [LangChain](https://python.langchain.com/) / [LangGraph](https://langchain-ai.github.io/langgraph/) tools. This allows your agents to persist information and recall it across sessions using MemU as the long-term memory backend.
 
-## Installation
-
-Ensure you have MemU installed with the LangGraph optional dependencies:
-
-```bash
-uv sync --extra langgraph
-# OR
-pip install memu[langgraph]
-```
+## Overview
 
-## Usage
+This integration wraps the `MemoryService` and exposes two key tools:
+- **`save_memory`**: Persists text, conversation snippets, or facts associated with a user.
+- **`search_memory`**: Retrieves relevant memories based on semantic search queries.
 
-The integration exposes a helper class `MemULangGraphTools` that wraps MemU's `MemoryService` into LangChain-compatible tools.
+These tools are fully typed and compatible with LangGraph's `prebuilt.ToolNode` and LangChain's agents.
 
-### 1. Initialize MemoryService
-
-First, initialize the core memory service.
+## Installation
 
-```python
-from memu.app.service import MemoryService
+To use this integration, you need to install the optional dependencies:
 
-service = MemoryService()
+```bash
+uv add langgraph langchain-core
 ```
 
-### 2. Create Tools
+## Quick Start
 
-Pass the service to the adapter to generate the tools.
+Here is a complete example of how to initialize the MemU memory service and bind it to a LangGraph agent.
 
 ```python
+import asyncio
+import os
+from memu.app.service import MemoryService
 from memu.integrations.langgraph import MemULangGraphTools
 
-adapter = MemULangGraphTools(service)
-tools = adapter.tools()
-# tools now contains [save_memory, search_memory]
+# Ensure you have your configuration set (e.g., env vars for DB connection)
+# os.environ["MEMU_DATABASE_URL"] = "..."
+
+async def main():
+    # 1. Initialize MemoryService
+    memory_service = MemoryService()
+    # If your service requires async init (check your specific implementation):
+    # await memory_service.initialize()
+
+    # 2. Instantiate MemULangGraphTools
+    memu_tools = MemULangGraphTools(memory_service)
+
+    # Get the list of tools (BaseTool compatible)
+    tools = memu_tools.tools()
+
+    # 3. Example Usage: Manually invoking a tool
+    # In a real app, you would pass 'tools' to your LangGraph agent or StateGraph.
+
+    # Save a memory
+    save_tool = memu_tools.save_memory_tool()
+    print("Saving memory...")
+    result = await save_tool.ainvoke({
+        "content": "The user prefers dark mode.",
+        "user_id": "user_123",
+        "metadata": {"category": "preferences"}
+    })
+    print(f"Save Result: {result}")
+
+    # Search for a memory
+    search_tool = memu_tools.search_memory_tool()
+    print("\nSearching memory...")
+    search_result = await search_tool.ainvoke({
+        "query": "What are the user's preferences?",
+        "user_id": "user_123"
+    })
+    print(f"Search Result:\n{search_result}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
 ```
 
-### 3. Integrate with LangGraph
-
-Add the tools to your LangGraph `ToolNode` or bind them to your LLM.
-
-```python
-from langgraph.prebuilt import ToolNode
-from langchain_openai import ChatOpenAI
+## API Reference
 
-# Bind tools to LLM
-llm = ChatOpenAI(model="gpt-4")
-llm_with_tools = llm.bind_tools(tools)
+### `MemULangGraphTools`
 
-# Create ToolNode
-tool_node = ToolNode(tools=tools)
+The main adapter class.
 
-# ... Build your StateGraph using tool_node ...
+```python
+class MemULangGraphTools(memory_service: MemoryService)
 ```
 
-## Available Tools
-
-### `save_memory`
-Allows the agent to save important information, user preferences, or conversation snippets to long-term memory.
-
-- **Arguments:**
-  - `content` (str): The information to save.
-  - `user_id` (str): The user associated with this memory.
-  - `metadata` (dict, optional): Additional context (e.g., category, importance).
-
-### `search_memory`
-Allows the agent to retrieve relevant information from memory based on a query.
+#### `save_memory_tool() -> StructuredTool`
+Returns a tool named `save_memory`.
+- **Inputs**: `content` (str), `user_id` (str), `metadata` (dict, optional).
+- **Description**: Save a piece of information, conversation snippet, or memory for a user.
 
-- **Arguments:**
-  - `query` (str): The question or topic to search for.
-  - `user_id` (str): The user associated with this memory.
-  - `limit` (int, default=5): Number of results to return.
+#### `search_memory_tool() -> StructuredTool`
+Returns a tool named `search_memory`.
+- **Inputs**: `query` (str), `user_id` (str), `limit` (int, default=5), `metadata_filter` (dict, optional), `min_relevance_score` (float, default=0.0).
+- **Description**: Search for relevant memories or information for a user based on a query.
 
-## Example
+## Troubleshooting
 
-See `examples/langgraph_demo.py` for a complete running example of a chatbot that uses MemU to remember user details across sessions.
+### Import Errors
+If you see an `ImportError` regarding `langchain_core` or `langgraph`:
+1. Ensure you have installed the extras: `uv add langgraph langchain-core` (or `pip install langgraph langchain-core`).
+2. Verify your virtual environment is active.

examples/langgraph_demo.py

@@ -1,18 +1,16 @@
 import asyncio
 import os
 import sys
+from typing import Annotated, Any, Literal, TypedDict
 
 # Ensure we can import from src
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../src")))
 
-from typing import Annotated, Literal
-
 try:
-    from typing import TypedDict
-
-    from langchain_core.messages import HumanMessage
+    from langchain_core.messages import BaseMessage, HumanMessage
+    from langchain_core.tools import BaseTool
     from langchain_openai import ChatOpenAI
-    from langgraph.graph import END, START, StateGraph
+    from langgraph.graph import START, StateGraph
     from langgraph.graph.message import add_messages
     from langgraph.prebuilt import ToolNode
 except ImportError:
@@ -25,14 +23,14 @@
 
 # Define state
 class State(TypedDict):
-    messages: Annotated[list, add_messages]
+    messages: Annotated[list[BaseMessage], add_messages]
 
 
-def build_demo_graph(tools, llm_model):
+def build_demo_graph(tools: list[BaseTool], llm_model: ChatOpenAI) -> Any:
     """Build the LangGraph state graph for the demo."""
     llm_with_tools = llm_model.bind_tools(tools)
 
-    def chatbot(state: State):
+    def chatbot(state: State) -> dict[str, list[BaseMessage]]:
         return {"messages": [llm_with_tools.invoke(state["messages"])]}
 
     graph_builder = StateGraph(State)
@@ -43,20 +41,21 @@ def chatbot(state: State):
 
     graph_builder.add_edge(START, "chatbot")
 
-    def should_continue(state: State) -> Literal["tools", END]:
+    # Note: END is actually "__end__", we use the literal string for the Type Hint to avoid MyPy error
+    def should_continue(state: State) -> Literal["tools", "__end__"]:
         messages = state["messages"]
         last_message = messages[-1]
-        if last_message.tool_calls:
+        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
             return "tools"
-        return END
+        return "__end__"
 
     graph_builder.add_conditional_edges("chatbot", should_continue)
     graph_builder.add_edge("tools", "chatbot")
 
     return graph_builder.compile()
 
 
-async def initialize_infrastructure():
+async def initialize_infrastructure() -> tuple[MemoryService | None, list[BaseTool] | None]:
     """Initialize MemoryService and MemULangGraphTools."""
     print("=== MemU LangGraph Demo ===")
     try:
@@ -73,7 +72,7 @@ async def initialize_infrastructure():
     return service, tools
 
 
-async def process_conversation(graph, user_input: str):
+async def process_conversation(graph: Any, user_input: str) -> None:
     """Handle the main conversation flow."""
     print(f"\nUser: {user_input}")
     events = graph.stream({"messages": [HumanMessage(content=user_input)]}, stream_mode="values")
@@ -83,13 +82,14 @@ async def process_conversation(graph, user_input: str):
             last_msg = event["messages"][-1]
             if last_msg.type == "ai":
                 print(f"Agent: {last_msg.content}")
-                if last_msg.tool_calls:
+                # Check for tool_calls safely
+                if hasattr(last_msg, "tool_calls") and last_msg.tool_calls:
                     print(f"   (Tool Call: {last_msg.tool_calls})")
             elif last_msg.type == "tool":
                 print(f"Tool Output: {last_msg.content}")
 
 
-async def process_retrieval(graph, search_input: str):
+async def process_retrieval(graph: Any, search_input: str) -> None:
     """Handle the retrieval flow."""
     print(f"\nUser: {search_input}")
     events = graph.stream({"messages": [HumanMessage(content=search_input)]}, stream_mode="values")
@@ -101,13 +101,15 @@ async def process_retrieval(graph, search_input: str):
                 print(f"Agent: {last_msg.content}")
 
 
-async def run_demo():
+async def run_demo() -> None:
     """Main orchestration function."""
-    service, tools = await initialize_infrastructure()
-    if not service:
+    service_and_tools = await initialize_infrastructure()
+    service, tools = service_and_tools
+
+    if not service or not tools:
         return
 
-    if not os.getenv("OPENAI_API_KEY"):
+    if not os.environ.get("OPENAI_API_KEY"):
         print("⚠️  OPENAI_API_KEY not found. Please set it to run the agent.")
         return
 

pyproject.toml

@@ -26,8 +26,6 @@ dependencies = [
     "sqlmodel>=0.0.27",
     "alembic>=1.14.0",
     "pendulum>=3.1.0",
-    "langgraph>=1.0.6",
-    "langchain-openai>=1.1.7",
     "langchain-core>=1.2.7",
 ]
 
@@ -45,6 +43,8 @@ dev = [
     {include-group = "docs"},
     {include-group = "lint"},
     {include-group = "test"},
+    "langchain-openai>=1.1.7",
+    "langgraph>=1.0.6",
 ]
 docs = [
     "mkdocs>=1.6.1",