context-engineering: use Redis 8, fix 8088 refs, add tests

abrookins · abrookins · commit a0d7f33b8dcb · 2025-10-21T00:37:49.000-07:00
- Switch to Redis 8.2.1 (compose, tests via Testcontainers)
- Replace Redis Stack mentions in CE docs; remove RedisInsight port
- Default Agent Memory Server to http://localhost:8088; update notebooks
- Keep LangGraph checkpointer off; add TODO explaining async issue
- Remove deprecated APIs (RedisVL .connect, Pydantic .dict)
- Add tests: unit + Redis-backed tool-path integration
diff --git a/python-recipes/context-engineering/README.md b/python-recipes/context-engineering/README.md
@@ -116,7 +116,7 @@ docker-compose up -d
 docker-compose ps
 
 # Check Agent Memory Server health
-curl http://localhost:8000/health
+curl http://localhost:8088/health
 ```
 
 #### 2. Set Up the Reference Agent
diff --git a/python-recipes/context-engineering/SETUP.md b/python-recipes/context-engineering/SETUP.md
@@ -29,7 +29,7 @@ Your `.env` file should look like this:
 ```bash
 OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxx
 REDIS_URL=redis://localhost:6379
-AGENT_MEMORY_URL=http://localhost:8000
+AGENT_MEMORY_URL=http://localhost:8088
 ```
 
 **Important:** The `.env` file is already in `.gitignore` so your API key won't be committed to git.
@@ -46,12 +46,12 @@ docker-compose up -d
 docker-compose ps
 
 # Check that the Agent Memory Server is healthy
-curl http://localhost:8000/health
+curl http://localhost:8088/health
 ```
 
 You should see:
-- `redis-context-engineering` running on ports 6379 (Redis) and 8001 (RedisInsight)
-- `agent-memory-server` running on port 8000
+- `redis-context-engineering` running on port 6379 (Redis 8)
+- `agent-memory-server` running on port 8088
 
 ### Step 3: Install Python Dependencies
 
@@ -92,11 +92,11 @@ docker exec redis-context-engineering redis-cli ping
 ### Check Agent Memory Server
 ```bash
 # Test health endpoint
-curl http://localhost:8000/health
+curl http://localhost:8088/health
 # Should return: {"status":"healthy"}
 
 # Test that it can connect to Redis and has your API key
-curl http://localhost:8000/api/v1/namespaces
+curl http://localhost:8088/api/v1/namespaces
 # Should return a list of namespaces (may be empty initially)
 ```
 
@@ -151,15 +151,15 @@ docker exec redis-context-engineering redis-cli ping
 
 ### Port Already in Use
 
-If you get errors about ports already in use (6379, 8000, or 8001), you can either:
+If you get errors about ports already in use (6379 or 8088), you can either:
 
 1. Stop the conflicting service
 2. Change the ports in `docker-compose.yml`:
    ```yaml
    ports:
      - "6380:6379"  # Use 6380 instead of 6379
    ```
-   Then update `REDIS_URL` in your `.env` file accordingly.
+   Then update `REDIS_URL` or `AGENT_MEMORY_URL` in your `.env` file accordingly.
 
 ## Stopping Services
 
diff --git a/python-recipes/context-engineering/docker-compose.yml b/python-recipes/context-engineering/docker-compose.yml
@@ -1,10 +1,9 @@
 services:
   redis:
-    image: redis/redis-stack:latest
+    image: redis:8.2.1
     container_name: redis-context-engineering
     ports:
       - "6379:6379"
-      - "8001:8001"  # RedisInsight
     environment:
       - REDIS_ARGS=--save 60 1 --loglevel warning
     volumes:
@@ -20,7 +19,7 @@ services:
     container_name: agent-memory-server
     command: ["agent-memory", "api", "--host", "0.0.0.0", "--port", "8000", "--no-worker"]
     ports:
-      - "8000:8000"
+      - "8088:8000"  # Host port changed to avoid conflicts
     environment:
       - REDIS_URL=redis://redis:6379
       - OPENAI_API_KEY=${OPENAI_API_KEY}
diff --git a/python-recipes/context-engineering/notebooks/common_setup.py b/python-recipes/context-engineering/notebooks/common_setup.py
@@ -129,7 +129,7 @@ def setup_notebook(require_openai_key=True, require_memory_server=False):
     print(f"✅ REDIS_URL: {redis_url}")
     
     # Check AGENT_MEMORY_URL
-    memory_url = os.getenv("AGENT_MEMORY_URL", "http://localhost:8000")
+    memory_url = os.getenv("AGENT_MEMORY_URL", "http://localhost:8088")
     print(f"✅ AGENT_MEMORY_URL: {memory_url}")
     
     # Step 4: Check Agent Memory Server if required
diff --git a/python-recipes/context-engineering/notebooks/section-1-introduction/01_what_is_context_engineering.ipynb b/python-recipes/context-engineering/notebooks/section-1-introduction/01_what_is_context_engineering.ipynb
@@ -404,7 +404,7 @@
     "\n",
     "# Initialize memory client\n",
     "config = MemoryClientConfig(\n",
-    "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8000\"),\n",
+    "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8088\"),\n",
     "    default_namespace=\"redis_university\"\n",
     ")\n",
     "memory_client = MemoryClient(config=config)\n",
diff --git a/python-recipes/context-engineering/notebooks/section-1-introduction/02_project_overview.ipynb b/python-recipes/context-engineering/notebooks/section-1-introduction/02_project_overview.ipynb
@@ -187,7 +187,7 @@
         "Example:\n",
         "```python\n",
         "from agent_memory_client import MemoryClient, MemoryClientConfig\n",
-        "cfg = MemoryClientConfig(base_url=\"http://localhost:8000\", default_namespace=\"redis_university\")\n",
+        "cfg = MemoryClientConfig(base_url=\"http://localhost:8088\", default_namespace=\"redis_university\")\n",
         "mem = MemoryClient(config=cfg)\n",
         "mem.store(entity_id=\"alex\", kind=\"preference\", text=\"Prefers online courses\")\n",
         "related = mem.search(entity_id=\"alex\", query=\"online\", k=3)\n",
diff --git a/python-recipes/context-engineering/notebooks/section-4-optimizations/01_context_window_management.ipynb b/python-recipes/context-engineering/notebooks/section-4-optimizations/01_context_window_management.ipynb
@@ -133,7 +133,7 @@
         "# Initialize memory client with proper config\n",
         "import os\n",
         "config = MemoryClientConfig(\n",
-        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8000\"),\n",
+        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8088\"),\n",
         "    default_namespace=\"redis_university\"\n",
         ")\n",
         "memory_client = MemoryClient(config=config)\n",
diff --git a/python-recipes/context-engineering/notebooks/section-4-optimizations/02_retrieval_strategies.ipynb b/python-recipes/context-engineering/notebooks/section-4-optimizations/02_retrieval_strategies.ipynb
@@ -162,7 +162,7 @@
         "# Initialize memory client with proper config\n",
         "import os\n",
         "config = MemoryClientConfig(\n",
-        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8000\"),\n",
+        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8088\"),\n",
         "    default_namespace=\"redis_university\"\n",
         ")\n",
         "memory_client = MemoryClient(config=config)\n",
diff --git a/python-recipes/context-engineering/notebooks/section-4-optimizations/03_grounding_with_memory.ipynb b/python-recipes/context-engineering/notebooks/section-4-optimizations/03_grounding_with_memory.ipynb
@@ -114,7 +114,7 @@
         "# Initialize memory client with proper config\n",
         "import os\n",
         "config = MemoryClientConfig(\n",
-        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8000\"),\n",
+        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8088\"),\n",
         "    default_namespace=\"redis_university\"\n",
         ")\n",
         "memory_client = MemoryClient(config=config)\n",
diff --git a/python-recipes/context-engineering/notebooks/section-4-optimizations/05_crafting_data_for_llms.ipynb b/python-recipes/context-engineering/notebooks/section-4-optimizations/05_crafting_data_for_llms.ipynb
@@ -166,7 +166,7 @@
         "# Initialize memory client with proper config\n",
         "import os\n",
         "config = MemoryClientConfig(\n",
-        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8000\"),\n",
+        "    base_url=os.getenv(\"AGENT_MEMORY_URL\", \"http://localhost:8088\"),\n",
         "    default_namespace=\"redis_university\"\n",
         ")\n",
         "memory_client = MemoryClient(config=config)\n",
diff --git a/python-recipes/context-engineering/reference-agent/README.md b/python-recipes/context-engineering/reference-agent/README.md
@@ -64,15 +64,15 @@ uv run agent-memory api --no-worker
 
 # Or with Docker
 docker run -d --name agent-memory \
-  -p 8000:8000 \
+  -p 8088:8000 \
   -e REDIS_URL=redis://host.docker.internal:6379 \
   -e OPENAI_API_KEY=your-key \
   redis/agent-memory-server
 ```
 
-Set the Agent Memory Server URL (optional, defaults to localhost:8000):
+Set the Agent Memory Server URL (optional, defaults to localhost:8088):
 ```bash
-export AGENT_MEMORY_URL="http://localhost:8000"
+export AGENT_MEMORY_URL="http://localhost:8088"
 ```
 
 ### 4. Generate Sample Data
diff --git a/python-recipes/context-engineering/reference-agent/redis_context_course/agent.py b/python-recipes/context-engineering/reference-agent/redis_context_course/agent.py
@@ -14,6 +14,8 @@
   * Accessible via tools
 """
 
+import os
+
 import json
 from typing import List, Dict, Any, Optional, Annotated
 from datetime import datetime
@@ -52,7 +54,7 @@ def __init__(self, student_id: str, session_id: Optional[str] = None):
 
         # Initialize memory client with proper config
         config = MemoryClientConfig(
-            base_url=os.getenv("AGENT_MEMORY_URL", "http://localhost:8000"),
+            base_url=os.getenv("AGENT_MEMORY_URL", "http://localhost:8088"),
             default_namespace="redis_university"
         )
         self.memory_client = MemoryAPIClient(config=config)
@@ -61,7 +63,7 @@ def __init__(self, student_id: str, session_id: Optional[str] = None):
 
         # Build the agent graph
         self.graph = self._build_graph()
-    
+
     def _build_graph(self) -> StateGraph:
         """
         Build the LangGraph workflow.
@@ -108,10 +110,14 @@ def _build_graph(self) -> StateGraph:
         workflow.add_edge("respond", "save_working_memory")
         workflow.add_edge("save_working_memory", END)
 
-        # Compile with Redis checkpointer for graph state persistence
-        # Note: This is separate from Agent Memory Server's working memory
-        return workflow.compile(checkpointer=redis_config.checkpointer)
-    
+        # Compile graph without Redis checkpointer
+        # TODO(CE-Checkpointer): Re-enable Redis checkpointer once langgraph's async
+        # checkpointer interface is compatible in our environment. Current versions
+        # raise NotImplementedError on aget_tuple via AsyncPregelLoop. Track and
+        # fix by upgrading langgraph (and/or using the correct async RedisSaver)
+        # and then switch to: workflow.compile(checkpointer=redis_config.checkpointer)
+        return workflow.compile()
+
     async def _load_working_memory(self, state: AgentState) -> AgentState:
         """
         Load working memory from Agent Memory Server.
@@ -150,8 +156,10 @@ async def _retrieve_context(self, state: AgentState) -> AgentState:
 
         # Search long-term memories for relevant context
         if state.current_query:
-            memories = await self.memory_client.search_memories(
-                query=state.current_query,
+            from agent_memory_client.filters import UserId
+            results = await self.memory_client.search_long_term_memory(
+                text=state.current_query,
+                user_id=UserId(eq=self.student_id),
                 limit=5
             )
 
@@ -162,7 +170,7 @@ async def _retrieve_context(self, state: AgentState) -> AgentState:
                 "recent_facts": []
             }
 
-            for memory in memories:
+            for memory in results.memories:
                 if memory.memory_type == "semantic":
                     if "preference" in memory.topics:
                         context["preferences"].append(memory.text)
@@ -174,7 +182,7 @@ async def _retrieve_context(self, state: AgentState) -> AgentState:
             state.context = context
 
         return state
-    
+
     async def _agent_node(self, state: AgentState) -> AgentState:
         """Main agent reasoning node."""
         # Build system message with context
@@ -188,14 +196,14 @@ async def _agent_node(self, state: AgentState) -> AgentState:
         state.messages.append(response)
 
         return state
-    
+
     def _should_use_tools(self, state: AgentState) -> str:
         """Determine if tools should be used or if we should respond."""
         last_message = state.messages[-1]
         if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
             return "tools"
         return "respond"
-    
+
     async def _respond_node(self, state: AgentState) -> AgentState:
         """Generate final response."""
         # The response is already in the last message
@@ -218,10 +226,13 @@ async def _save_working_memory(self, state: AgentState) -> AgentState:
         # Convert LangChain messages to simple dict format
         messages = []
         for msg in state.messages:
+            content = getattr(msg, "content", None)
+            if not content:
+                continue
             if isinstance(msg, HumanMessage):
-                messages.append({"role": "user", "content": msg.content})
+                messages.append({"role": "user", "content": content})
             elif isinstance(msg, AIMessage):
-                messages.append({"role": "assistant", "content": msg.content})
+                messages.append({"role": "assistant", "content": content})
 
         # Save to working memory
         # The Agent Memory Server will automatically extract important memories
@@ -248,7 +259,7 @@ async def _save_working_memory(self, state: AgentState) -> AgentState:
         )
 
         return state
-    
+
     def _build_system_prompt(self, context: Dict[str, Any]) -> str:
         """Build system prompt with current context."""
         prompt = """You are a helpful Redis University Class Agent powered by Redis Agent Memory Server.
@@ -429,8 +440,15 @@ async def chat(self, message: str, thread_id: str = "default") -> str:
         config = {"configurable": {"thread_id": thread_id}}
         result = await self.graph.ainvoke(initial_state, config)
 
+        # Handle result structure (dict-like or object)
+        result_messages = []
+        if isinstance(result, dict) or hasattr(result, "get"):
+            result_messages = result.get("messages", [])
+        else:
+            result_messages = getattr(result, "messages", [])
+
         # Return the last AI message
-        ai_messages = [msg for msg in result.messages if isinstance(msg, AIMessage)]
+        ai_messages = [msg for msg in result_messages if isinstance(msg, AIMessage)]
         if ai_messages:
             return ai_messages[-1].content
 
diff --git a/python-recipes/context-engineering/reference-agent/redis_context_course/course_manager.py b/python-recipes/context-engineering/reference-agent/redis_context_course/course_manager.py
@@ -85,8 +85,9 @@ async def store_course(self, course: Course) -> str:
             "max_enrollment": course.max_enrollment,
             "current_enrollment": course.current_enrollment,
             "learning_objectives": json.dumps(course.learning_objectives),
-            "prerequisites": json.dumps([p.dict() for p in course.prerequisites]),
-            "schedule": json.dumps(course.schedule.dict()) if course.schedule else "",
+            "prerequisites": json.dumps([p.model_dump() for p in course.prerequisites]),
+            # Use default=str to handle datetime.time serialization
+            "schedule": json.dumps(course.schedule.model_dump(), default=str) if course.schedule else "",
             "created_at": course.created_at.timestamp(),
             "updated_at": course.updated_at.timestamp(),
             "content_vector": np.array(embedding, dtype=np.float32).tobytes()
diff --git a/python-recipes/context-engineering/reference-agent/redis_context_course/redis_config.py b/python-recipes/context-engineering/reference-agent/redis_context_course/redis_config.py
@@ -118,10 +118,10 @@ def vector_index(self) -> SearchIndex:
                     }
                 ]
             })
-            
-            self._vector_index = SearchIndex(schema)
-            self._vector_index.connect(redis_url=self.redis_url)
-            
+
+            # Initialize index with connection params (avoid deprecated .connect())
+            self._vector_index = SearchIndex(schema, redis_url=self.redis_url)
+
             # Create index if it doesn't exist
             try:
                 self._vector_index.create(overwrite=False)
@@ -136,8 +136,7 @@ def checkpointer(self) -> RedisSaver:
         """Get Redis checkpointer for LangGraph state management."""
         if self._checkpointer is None:
             self._checkpointer = RedisSaver(
-                redis_client=self.redis_client,
-                namespace=self.checkpoint_namespace
+                redis_client=self.redis_client
             )
             self._checkpointer.setup()
         return self._checkpointer
diff --git a/python-recipes/context-engineering/reference-agent/redis_context_course/scripts/ingest_courses.py b/python-recipes/context-engineering/reference-agent/redis_context_course/scripts/ingest_courses.py
@@ -10,6 +10,7 @@
 import asyncio
 import sys
 import os
+from datetime import datetime
 from typing import List, Dict, Any
 import click
 from rich.console import Console
@@ -136,7 +137,16 @@ def ingest_majors(self, majors_data: List[Dict[str, Any]]) -> int:
                     major = self._dict_to_major(major_data)
                     # Store major data in Redis (simple hash storage)
                     key = f"major:{major.id}"
-                    self.redis_client.hset(key, mapping=major.dict())
+                    # Convert any non-scalar fields to JSON strings for Redis hash storage
+                    major_map = {}
+                    for k, v in major.dict().items():
+                        if isinstance(v, (list, dict)):
+                            major_map[k] = json.dumps(v)
+                        elif isinstance(v, datetime):
+                            major_map[k] = v.isoformat()
+                        else:
+                            major_map[k] = v
+                    self.redis_client.hset(key, mapping=major_map)
                     ingested_count += 1
                     progress.update(task, advance=1)
                 except Exception as e:
diff --git a/python-recipes/context-engineering/reference-agent/tests/conftest.py b/python-recipes/context-engineering/reference-agent/tests/conftest.py
@@ -0,0 +1,20 @@
+import os
+import time
+import pytest
+from testcontainers.core.container import DockerContainer
+
+
+@pytest.fixture(scope="session")
+def redis_stack_url():
+    """Start a Redis 8 container (modules built-in) and yield REDIS_URL."""
+    image = os.getenv("TEST_REDIS_IMAGE", "redis:8.2.1")
+    with DockerContainer(image) as c:
+        c.with_exposed_ports(6379)
+        c.start()
+        host = c.get_container_host_ip()
+        port = int(c.get_exposed_port(6379))
+        url = f"redis://{host}:{port}"
+        # Tiny wait for readiness
+        time.sleep(1.0)
+        yield url
+
diff --git a/python-recipes/context-engineering/reference-agent/tests/test_agent_chat.py b/python-recipes/context-engineering/reference-agent/tests/test_agent_chat.py
diff --git a/python-recipes/context-engineering/reference-agent/tests/test_agent_tool_path.py b/python-recipes/context-engineering/reference-agent/tests/test_agent_tool_path.py
diff --git a/python-recipes/context-engineering/reference-agent/tests/test_tools.py b/python-recipes/context-engineering/reference-agent/tests/test_tools.py
