feat(protocols): add new protocols for enhanced functionality

- Introduced several new protocols including HasAddListenerProtocol, HasArrowStoreProtocol, HasErrorsProtocol, HasNameProtocol, HasNotifiesProtocol, HasRowcountProtocol, HasSqlStateProtocol, HasSqliteErrorProtocol, HasValueProtocol, and HasTypeCodeProtocol.
- Updated existing protocols to improve type safety and functionality.
- Enhanced ReadableProtocol to accept an optional size parameter for the read method.

refactor(storage): simplify row count handling in SyncStoragePipeline

- Removed unnecessary checks for has_arrow_table_stats when determining row counts in SyncStoragePipeline methods.
- Streamlined the logic for processing rows in both synchronous and asynchronous storage pipelines.

fix(module_loader): improve import_string error handling

- Refined the import_string function to handle attribute access more gracefully, reducing the likelihood of unhandled exceptions.

refactor(schema): optimize type checking and field access

- Improved type guards for dataclass and attrs instances, enhancing performance and readability.
- Simplified field access logic in extract_dataclass_fields and related functions.

test(adk): add integration tests for AioSQLite and SQLite memory stores

- Implemented comprehensive tests for memory store operations including insert, search, delete by session, and delete older than.
- Ensured that memory records are correctly handled and deduplicated.

test(unit): add unit tests for ADK memory converters

- Created tests for event and session conversion functions to validate correct behavior and output.

chore(tests): remove redundant has_attr tests

- Eliminated outdated tests for has_attr function, focusing on more relevant type guard tests.

Author: cofin

docs/changelog.rst

@@ -10,6 +10,21 @@ SQLSpec Changelog
 Recent Updates
 ==============
 
+ADK Memory Store
+----------------
+
+- Added ``SQLSpecMemoryService`` and ``SQLSpecSyncMemoryService`` for SQLSpec-backed ADK memory storage.
+- Implemented adapter-specific memory stores with optional full-text search (`memory_use_fts`) and simple fallback search.
+- Extended ADK migrations to include memory tables with configurable ``include_memory_migration`` toggles.
+- Added CLI commands for memory cleanup and verification (`sqlspec adk memory cleanup/verify`).
+
+Driver Layer Compilation
+------------------------
+
+- Compiled driver base classes and mixins with mypyc to reduce dispatch overhead in the execution pipeline.
+- Replaced dynamic ``getattr`` patterns with protocol-driven access for mypyc compatibility.
+- Added driver protocols and updated mypyc build configuration to include driver modules.
+
 Database Event Channels
 -----------------------
 

docs/examples/extensions/adk/litestar_aiosqlite.py

@@ -1,4 +1,4 @@
-"""Expose SQLSpec-backed ADK sessions through a Litestar endpoint."""
+"""Expose SQLSpec-backed ADK sessions and memory through Litestar endpoints."""
 
 import asyncio
 from typing import Any
@@ -7,18 +7,25 @@
 
 from sqlspec.adapters.aiosqlite import AiosqliteConfig
 from sqlspec.adapters.aiosqlite.adk import AiosqliteADKStore
+from sqlspec.adapters.aiosqlite.adk.memory_store import AiosqliteADKMemoryStore
 from sqlspec.extensions.adk import SQLSpecSessionService
+from sqlspec.extensions.adk.memory import SQLSpecMemoryService
 
 config = AiosqliteConfig(connection_config={"database": ":memory:"})
 service: "SQLSpecSessionService | None" = None
+memory_service: "SQLSpecMemoryService | None" = None
 
 
 async def startup() -> None:
     """Initialize the ADK store when the app boots."""
     global service
+    global memory_service
     store = AiosqliteADKStore(config)
+    memory_store = AiosqliteADKMemoryStore(config)
     await store.create_tables()
+    await memory_store.create_tables()
     service = SQLSpecSessionService(store)
+    memory_service = SQLSpecMemoryService(memory_store)
 
 
 @get("/sessions")
@@ -29,7 +36,15 @@ async def list_sessions() -> "dict[str, Any]":
     return {"count": len(sessions.sessions)}
 
 
-app = Litestar(route_handlers=[list_sessions], on_startup=[startup])
+@get("/memories")
+async def list_memories(query: str = "demo") -> "dict[str, Any]":
+    """Return memory count for a query string."""
+    assert memory_service is not None
+    response = await memory_service.search_memory(app_name="docs", user_id="demo", query=query)
+    return {"count": len(response.memories)}
+
+
+app = Litestar(route_handlers=[list_sessions, list_memories], on_startup=[startup])
 
 
 def main() -> None:

docs/examples/extensions/adk/litestar_aiosqlite.rst

@@ -1,8 +1,8 @@
 ADK + Litestar Endpoint
 =======================
 
-Initialize ``SQLSpecSessionService`` inside Litestar and expose a ``/sessions`` endpoint backed by
-AioSQLite.
+Initialize ``SQLSpecSessionService`` and ``SQLSpecMemoryService`` inside Litestar and expose
+``/sessions`` plus ``/memories`` endpoints backed by AioSQLite.
 
 .. code-block:: console
 

docs/examples/extensions/adk/runner_memory_aiosqlite.py

@@ -0,0 +1,53 @@
+"""Run an ADK agent with SQLSpec-backed session and memory services (AioSQLite)."""
+
+import asyncio
+
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.apps.app import App
+from google.adk.runners import Runner
+from google.genai import types
+
+from sqlspec.adapters.aiosqlite import AiosqliteConfig
+from sqlspec.adapters.aiosqlite.adk import AiosqliteADKStore
+from sqlspec.adapters.aiosqlite.adk.memory_store import AiosqliteADKMemoryStore
+from sqlspec.extensions.adk import SQLSpecSessionService
+from sqlspec.extensions.adk.memory import SQLSpecMemoryService
+
+__all__ = ("main",)
+
+
+async def main() -> None:
+    """Run a single ADK turn, then persist memory and search it."""
+    config = AiosqliteConfig(
+        connection_config={"database": ":memory:"}, extension_config={"adk": {"memory_use_fts": False}}
+    )
+    session_store = AiosqliteADKStore(config)
+    memory_store = AiosqliteADKMemoryStore(config)
+    await session_store.create_tables()
+    await memory_store.create_tables()
+
+    session_service = SQLSpecSessionService(session_store)
+    memory_service = SQLSpecMemoryService(memory_store)
+
+    agent = LlmAgent(name="sqlspec_agent", model="gemini-2.5-flash", instruction="Answer briefly.")
+    app = App(name="sqlspec_demo", root_agent=agent)
+    runner = Runner(app=app, session_service=session_service, memory_service=memory_service)
+
+    session_id = "session-1"
+    user_id = "demo-user"
+    await session_service.create_session(app_name=app.name, user_id=user_id, session_id=session_id)
+
+    new_message = types.UserContent(parts=[types.Part(text="Remember I like espresso.")])
+    async for _event in runner.run_async(user_id=user_id, session_id=session_id, new_message=new_message):
+        pass
+
+    session = await session_service.get_session(app_name=app.name, user_id=user_id, session_id=session_id)
+    if session:
+        await memory_service.add_session_to_memory(session)
+
+    response = await memory_service.search_memory(app_name=app.name, user_id=user_id, query="espresso")
+    print({"memories": len(response.memories)})
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

docs/examples/extensions/adk/runner_memory_aiosqlite.rst

@@ -0,0 +1,19 @@
+ADK Runner with Memory (AioSQLite)
+==================================
+
+Run an ADK ``Runner`` with SQLSpec-backed session and memory services, then
+persist memories from the completed session.
+
+This example requires Google ADK credentials (for example, a configured API key)
+and network access to the model provider.
+
+.. code-block:: console
+
+   uv run python docs/examples/extensions/adk/runner_memory_aiosqlite.py
+
+Source
+------
+
+.. literalinclude:: runner_memory_aiosqlite.py
+   :language: python
+   :linenos:

docs/examples/index.rst

@@ -128,6 +128,8 @@ Extensions
      - Create an ADK session, append events, and fetch the transcript using SQLSpec’s AioSQLite store.
    * - ``extensions/adk/litestar_aiosqlite.py``
      - Wire ``SQLSpecSessionService`` into Litestar and expose a simple ``/sessions`` endpoint.
+   * - ``extensions/adk/runner_memory_aiosqlite.py``
+     - Run an ADK ``Runner`` with SQLSpec-backed session + memory services, then query stored memories.
 
 Shared Utilities
 ----------------
@@ -150,6 +152,7 @@ Shared Utilities
    loaders/sql_files
    extensions/adk/basic_aiosqlite
    extensions/adk/litestar_aiosqlite
+   extensions/adk/runner_memory_aiosqlite
    frameworks/fastapi/aiosqlite_app
    frameworks/fastapi/sqlite_app
    frameworks/starlette/aiosqlite_app

docs/extensions/adk/api.rst

@@ -56,8 +56,54 @@ SQLSpecSessionService
       :doc:`/examples/extensions/adk/litestar_aiosqlite`
          Web framework integration using Litestar
 
-Base Store Classes
-==================
+Memory Service
+==============
+
+SQLSpecMemoryService
+--------------------
+
+.. autoclass:: sqlspec.extensions.adk.memory.SQLSpecMemoryService
+   :show-inheritance:
+
+   SQLSpec-backed implementation of Google ADK's ``BaseMemoryService``.
+
+   This service persists memories extracted from completed sessions and exposes
+   search capabilities via adapter-specific stores.
+
+   **Attributes:**
+
+   .. attribute:: store
+      :no-index:
+
+      The database store implementation (e.g., ``AsyncpgADKMemoryStore``).
+
+   **Example:**
+
+   .. code-block:: python
+
+      from sqlspec.adapters.asyncpg.adk.memory_store import AsyncpgADKMemoryStore
+      from sqlspec.extensions.adk.memory import SQLSpecMemoryService
+
+      store = AsyncpgADKMemoryStore(config)
+      await store.create_tables()
+      memory_service = SQLSpecMemoryService(store)
+
+   .. seealso::
+
+      :doc:`/examples/extensions/adk/runner_memory_aiosqlite`
+         ADK Runner example with SQLSpec-backed memory service
+
+SQLSpecSyncMemoryService
+------------------------
+
+.. autoclass:: sqlspec.extensions.adk.memory.SQLSpecSyncMemoryService
+   :show-inheritance:
+
+   Sync memory service for sync adapters (SQLite/DuckDB). This class does not
+   inherit from ADK's async ``BaseMemoryService`` but mirrors the async API.
+
+Session Store Base Classes
+==========================
 
 BaseAsyncADKStore
 ------------
@@ -170,6 +216,35 @@ BaseSyncADKStore
       store = SqliteADKStore(config)
       store.create_tables()
 
+Memory Store Base Classes
+=========================
+
+BaseAsyncADKMemoryStore
+-----------------------
+
+.. autoclass:: sqlspec.extensions.adk.memory.BaseAsyncADKMemoryStore
+   :show-inheritance:
+
+   Abstract base class for async SQLSpec-backed ADK memory stores.
+
+   **Abstract Methods:**
+
+   - :meth:`create_tables`
+   - :meth:`insert_memory_entries`
+   - :meth:`search_entries`
+   - :meth:`delete_entries_by_session`
+   - :meth:`delete_entries_older_than`
+   - :meth:`_get_create_memory_table_sql`
+   - :meth:`_get_drop_memory_table_sql`
+
+BaseSyncADKMemoryStore
+----------------------
+
+.. autoclass:: sqlspec.extensions.adk.memory.BaseSyncADKMemoryStore
+   :show-inheritance:
+
+   Abstract base class for sync SQLSpec-backed ADK memory stores.
+
 Type Definitions
 ================
 
@@ -218,6 +293,13 @@ SessionRecord
 
       from datetime import datetime, timezone
 
+MemoryRecord
+------------
+
+.. autoclass:: sqlspec.extensions.adk.memory._types.MemoryRecord
+
+   TypedDict representing a memory database record.
+
       record: SessionRecord = {
           "id": "550e8400-e29b-41d4-a716-446655440000",
           "app_name": "weather_agent",

docs/extensions/adk/index.rst

@@ -25,17 +25,18 @@ Google ADK Extension
    migrations
    schema
 
-Session and event storage for the Google Agent Development Kit (ADK) using SQLSpec database adapters.
+Session, event, and memory storage for the Google Agent Development Kit (ADK) using SQLSpec database adapters.
 
 Overview
 ========
 
-The SQLSpec ADK extension provides persistent storage for `Google Agent Development Kit <https://github.com/google/genai>`_ sessions and events, enabling stateful AI agent applications with database-backed conversation history.
+The SQLSpec ADK extension provides persistent storage for `Google Agent Development Kit <https://github.com/google/genai>`_ sessions, events, and long-term memory entries, enabling stateful AI agent applications with database-backed conversation history and recall.
 
 This extension implements ADK's ``BaseSessionService`` protocol, allowing AI agents to store and retrieve:
 
 - **Session State**: Persistent conversation context and application state
 - **Event History**: Complete record of user/assistant interactions
+- **Long-term Memory**: Searchable memory entries extracted from completed sessions
 - **Multi-User Support**: Isolated sessions per application and user
 - **Type-Safe Storage**: Full type safety with TypedDicts and validated records
 
@@ -149,25 +150,30 @@ The extension follows a layered architecture:
    └──────────┬──────────┘
               │
    ┌──────────▼──────────┐
-   │ SQLSpecSessionService│  ← Implements BaseSessionService
-   └──────────┬──────────┘
-              │
-   ┌──────────▼──────────┐
-   │ Store Implementation│  ← AsyncpgADKStore, SqliteADKStore, etc.
-   └──────────┬──────────┘
-              │
-   ┌──────────▼──────────┐
-   │  SQLSpec Config     │  ← AsyncpgConfig, SqliteConfig, etc.
+   ┌─────────────────────┐
+   │     ADK Runner       │
    └──────────┬──────────┘
               │
-   ┌──────────▼──────────┐
-   │    Database         │
-   └─────────────────────┘
+   ┌──────────▼──────────┐        ┌────────────────────┐
+   │ SQLSpecSessionService│        │ SQLSpecMemoryService│
+   └──────────┬──────────┘        └──────────┬─────────┘
+              │                             │
+   ┌──────────▼──────────┐        ┌─────────▼─────────┐
+   │ Session Store       │        │ Memory Store      │
+   └──────────┬──────────┘        └─────────┬─────────┘
+              │                             │
+   ┌──────────▼──────────┐        ┌─────────▼─────────┐
+   │  SQLSpec Config     │        │  SQLSpec Config   │
+   └──────────┬──────────┘        └─────────┬─────────┘
+              │                             │
+   ┌──────────▼──────────┐        ┌─────────▼─────────┐
+   │    Database         │        │    Database       │
+   └─────────────────────┘        └───────────────────┘
 
 **Layers:**
 
-1. **Service Layer** (``SQLSpecSessionService``): Implements ADK's ``BaseSessionService`` protocol
-2. **Store Layer** (``BaseAsyncADKStore``): Abstract database operations for each adapter
+1. **Service Layer** (``SQLSpecSessionService`` / ``SQLSpecMemoryService``): Implements ADK service protocols
+2. **Store Layer** (``BaseAsyncADKStore`` / ``BaseAsyncADKMemoryStore``): Abstract database operations per adapter
 3. **Config Layer** (SQLSpec): Connection pooling and resource management
 4. **Database Layer**: Physical storage with database-specific optimizations
 
@@ -178,6 +184,7 @@ New curated examples live in the :doc:`examples catalog </examples/index>`:
 
 * :doc:`/examples/extensions/adk/basic_aiosqlite` – create a session, append two events, and read the transcript using AioSQLite storage.
 * :doc:`/examples/extensions/adk/litestar_aiosqlite` – initialize ``SQLSpecSessionService`` inside a Litestar app and expose a ``/sessions`` route.
+* :doc:`/examples/extensions/adk/runner_memory_aiosqlite` – run an ADK ``Runner`` with SQLSpec-backed memory and search stored memories.
 
 Use Cases
 =========

docs/extensions/adk/migrations.rst

@@ -55,6 +55,8 @@ Setting Up Migrations
            "adk": {
                "session_table": "adk_sessions",
                "events_table": "adk_events",
+               "memory_table": "adk_memory_entries",
+               "memory_use_fts": True,
                "owner_id_column": "account_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE"
            }
        },
@@ -76,6 +78,13 @@ Setting Up Migrations
    ``owner_id_column`` configuration when creating tables. The column is added to
    the sessions table DDL if specified in ``extension_config["adk"]["owner_id_column"]``.
 
+.. note::
+
+   **Memory Tables**: ``ext_adk_0001`` also creates the memory table when
+   ``enable_memory`` (default) or ``include_memory_migration`` is set to ``True``.
+   Set ``include_memory_migration=False`` to skip memory DDL while keeping the
+   runtime memory service enabled.
+
 **2. Initialize Migration Directory:**
 
 .. code-block:: bash

docs/extensions/adk/quickstart.rst

@@ -100,6 +100,21 @@ Create the session service that implements ADK's ``BaseSessionService`` protocol
        service = SQLSpecSessionService(store)
        return service
 
+Optional: Initialize Memory Service
+===================================
+
+If you want long-term memory search, create a memory store and service alongside the session service:
+
+.. code-block:: python
+
+   from sqlspec.adapters.asyncpg.adk.memory_store import AsyncpgADKMemoryStore
+   from sqlspec.extensions.adk.memory import SQLSpecMemoryService
+
+   async def create_memory_service(config):
+       memory_store = AsyncpgADKMemoryStore(config)
+       await memory_store.create_tables()
+       return SQLSpecMemoryService(memory_store)
+
 Step 5: Create a Session
 =========================