Refactor OpenMemory Sample to Use get_fast_api_app with URI Scheme

Author: rakshith-git

contributing/samples/open_memory/README.md

@@ -44,7 +44,24 @@ OPENMEMORY_BASE_URL=http://localhost:8080
 
 ## Usage
 
-The sample provides an agent definition that you can use programmatically. The agent includes memory tools and auto-save functionality.
+### Option 1: Using `get_fast_api_app` with URI (Recommended - Easiest)
+
+The simplest way to use this sample is to run the included `main.py`:
+
+```bash
+python main.py
+```
+
+The `main.py` file demonstrates how to:
+- Register the OpenMemory service factory for the `openmemory://` URI scheme
+- Use the `openmemory://` URI scheme with `get_fast_api_app`
+- Build the URI from environment variables
+
+**Note:** The `adk web` CLI command won't work directly with this sample because it doesn't automatically register the OpenMemory service factory. You must use `main.py` which handles the registration.
+
+### Option 2: Using `Runner` Directly
+
+For programmatic usage, you can use `Runner` with OpenMemory service directly:
 
 ```python
 from google.adk_community.memory import OpenMemoryService, OpenMemoryServiceConfig
@@ -87,10 +104,21 @@ memory_service = OpenMemoryService(
 )
 ```
 
+## Sample Structure
+
+```
+open_memory/
+├── main.py                    # FastAPI server using get_fast_api_app (Option 1)
+├── open_memory_agent/
+│   ├── __init__.py            # Agent package initialization
+│   └── agent.py               # Agent definition with memory tools
+└── README.md                  # This file
+```
+
 ## Sample Agent
 
-The sample agent (`agent.py`) includes:
-- Memory tools (`load_memory_tool`, `preload_memory_tool`) for retrieving past conversations
+The sample agent (`open_memory_agent/agent.py`) includes:
+- Memory tools (`load_memory`, `preload_memory`) for retrieving past conversations
 - Auto-save callback that saves sessions to memory after each agent turn
 - Time context for the agent to use current time in responses
 
@@ -104,6 +132,12 @@ Then in a new session
 
 ## Configuration Options
 
+### OpenMemory URI Format
+
+When using `get_fast_api_app` (Option 1), you can use the `openmemory://` URI scheme:
+
+- `openmemory://localhost:8080` - API key must be set via `OPENMEMORY_API_KEY` environment variable
+
 ### OpenMemoryServiceConfig
 
 - `search_top_k` (int, default: 10): Maximum memories to retrieve per search

contributing/samples/open_memory/main.py

@@ -0,0 +1,60 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Example of using OpenMemory with get_fast_api_app."""
+
+import os
+import uvicorn
+from dotenv import load_dotenv
+from fastapi import FastAPI
+from urllib.parse import urlparse
+from google.adk.cli.fast_api import get_fast_api_app
+from google.adk.cli.service_registry import get_service_registry
+from google.adk_community.memory import OpenMemoryService
+
+# Load environment variables from .env file if it exists
+load_dotenv()
+
+# Register OpenMemory service factory for openmemory:// URI scheme
+def openmemory_factory(uri: str, **kwargs):
+    parsed = urlparse(uri)
+    location = parsed.netloc + parsed.path
+    base_url = location if location.startswith(('http://', 'https://')) else f'http://{location}'
+    api_key = os.getenv('OPENMEMORY_API_KEY', '')
+    if not api_key:
+        raise ValueError("OpenMemory API key required. Set OPENMEMORY_API_KEY environment variable.")
+    return OpenMemoryService(base_url=base_url, api_key=api_key)
+
+get_service_registry().register_memory_service("openmemory", openmemory_factory)
+
+# Build OpenMemory URI from environment variables (API key comes from env var)
+base_url = os.getenv('OPENMEMORY_BASE_URL', 'http://localhost:8080').replace('http://', '').replace('https://', '')
+MEMORY_SERVICE_URI = f"openmemory://{base_url}"
+
+# Allowed origins for CORS
+ALLOWED_ORIGINS = ["*"]
+
+# Create the FastAPI app using get_fast_api_app
+app: FastAPI = get_fast_api_app(
+    agents_dir=".",
+    memory_service_uri=MEMORY_SERVICE_URI,
+    allow_origins=ALLOWED_ORIGINS,
+    web=True,
+)
+
+if __name__ == '__main__':
+    # Use the PORT environment variable provided by Cloud Run, defaulting to 8000
+    port = int(os.environ.get('PORT', 8000))
+    uvicorn.run(app, host='0.0.0.0', port=port)
+

…ributing/samples/open_memory/__init__.py …pen_memory/open_memory_agent/__init__.pycontributing/samples/open_memory/__init__.py renamed to contributing/samples/open_memory/open_memory_agent/__init__.py contributing/samples/open_memory/__init__.py renamed to contributing/samples/open_memory/open_memory_agent/__init__.py

@@ -14,39 +14,25 @@
 
 
 from datetime import datetime
-
 from google.adk import Agent
 from google.adk.agents.callback_context import CallbackContext
-from google.adk.tools.load_memory_tool import load_memory_tool
-from google.adk.tools.preload_memory_tool import preload_memory_tool
+from google.adk.tools import load_memory, preload_memory
 
 
 def update_current_time(callback_context: CallbackContext):
   callback_context.state['_time'] = datetime.now().isoformat()
 
-
-async def auto_save_session_to_memory_callback(callback_context: CallbackContext):
-  """Auto-saves the current session to memory after each agent turn.
-  
-  Since there's no automatic save (saves only happen when the PATCH /memory endpoint
-  is called), this callback is a simple workaround for testing that saves memories
-  after each agent turn.
-  """
-  if callback_context._invocation_context.memory_service:
-    await callback_context._invocation_context.memory_service.add_session_to_memory(
-        callback_context._invocation_context.session)
-
-
 root_agent = Agent(
     model='gemini-2.5-flash',
     name='open_memory_agent',
-    description='agent that has access to memory tools with OpenMemory.',
+    description='agent that has access to memory tools with OpenMemory via get_fast_api_app.',
     before_agent_callback=update_current_time,
-    after_agent_callback=auto_save_session_to_memory_callback,
     instruction=(
         'You are an agent that helps user answer questions. You have access to memory tools.\n'
-        'You can use the memory tools to look up the information in the memory. Current time: {_time}'
+        'When the user asks a question you do not know the answer to, you MUST use the load_memory tool to search for relevant information from past conversations.\n'
+        'If the first search does not find relevant information, try different search terms or keywords related to the question.\n'
+        'Current time: {_time}'
     ),
-    tools=[load_memory_tool, preload_memory_tool],
+    tools=[preload_memory, load_memory],
 )