diff --git a/pkg-py/CHANGELOG.md b/pkg-py/CHANGELOG.md
index 901f47ac..9b600116 100644
--- a/pkg-py/CHANGELOG.md
+++ b/pkg-py/CHANGELOG.md
@@ -7,7 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [UNRELEASED]
 
+### New features
+
+* `QueryChat.client()` can now create standalone querychat-enabled chat clients with configurable tools and callbacks, enabling use outside of Shiny applications. (#168)
+
+* `QueryChat.console()` was added to launch interactive console-based chat sessions with your data source, with persistent conversation state across invocations. (#168)
 
+* The tools used in a `QueryChat` chatbot are now configurable. Use the new `tools` parameter of `QueryChat()` to select either or both `"query"` or `"update"` tools. Choose `tools=["update"]` if you only want QueryChat to be able to update the dashboard (useful when you want to be 100% certain that the LLM will not see _any_ raw data). (#168)
 
 ## [0.3.0] - 2025-12-10
 
diff --git a/pkg-py/src/querychat/_querychat.py b/pkg-py/src/querychat/_querychat.py
index 1ab03f53..8a7469e4 100644
--- a/pkg-py/src/querychat/_querychat.py
+++ b/pkg-py/src/querychat/_querychat.py
@@ -17,11 +17,23 @@
 from ._datasource import DataFrameSource, DataSource, SQLAlchemySource
 from ._icons import bs_icon
 from ._querychat_module import GREETING_PROMPT, ServerValues, mod_server, mod_ui
+from ._system_prompt import QueryChatSystemPrompt
+from ._utils import MISSING, MISSING_TYPE
+from .tools import (
+    UpdateDashboardData,
+    tool_query,
+    tool_reset_dashboard,
+    tool_update_dashboard,
+)
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     import pandas as pd
     from narwhals.stable.v1.typing import IntoFrame
 
+TOOL_GROUPS = Literal["update", "query"]
+
 
 class QueryChatBase:
     def __init__(
@@ -32,6 +44,7 @@ def __init__(
         id: Optional[str] = None,
         greeting: Optional[str | Path] = None,
         client: Optional[str | chatlas.Chat] = None,
+        tools: TOOL_GROUPS | tuple[TOOL_GROUPS, ...] | None = ("update", "query"),
         data_description: Optional[str | Path] = None,
         categorical_threshold: int = 20,
         extra_instructions: Optional[str | Path] = None,
@@ -47,21 +60,28 @@ def __init__(
 
         self.id = id or table_name
 
+        self.tools = normalize_tools(tools, default=("update", "query"))
         self.greeting = greeting.read_text() if isinstance(greeting, Path) else greeting
 
-        prompt = assemble_system_prompt(
-            self._data_source,
+        # Store prompt components for lazy assembly
+        if prompt_template is None:
+            prompt_template = Path(__file__).parent / "prompts" / "prompt.md"
+
+        self._system_prompt = QueryChatSystemPrompt(
+            prompt_template=prompt_template,
+            data_source=self._data_source,
             data_description=data_description,
             extra_instructions=extra_instructions,
             categorical_threshold=categorical_threshold,
-            prompt_template=prompt_template,
         )
 
         # Fork and empty chat now so the per-session forks are fast
         client = as_querychat_client(client)
         self._client = copy.deepcopy(client)
         self._client.set_turns([])
-        self._client.system_prompt = prompt
+
+        # Storage for console client
+        self._client_console = None
 
     def app(
         self, *, bookmark_store: Literal["url", "server", "disable"] = "url"
@@ -241,6 +261,158 @@ def generate_greeting(self, *, echo: Literal["none", "output"] = "none"):
         client.set_turns([])
         return str(client.chat(GREETING_PROMPT, echo=echo))
 
+    def client(
+        self,
+        *,
+        tools: TOOL_GROUPS | tuple[TOOL_GROUPS, ...] | None | MISSING_TYPE = MISSING,
+        update_dashboard: Callable[[UpdateDashboardData], None] | None = None,
+        reset_dashboard: Callable[[], None] | None = None,
+    ) -> chatlas.Chat:
+        """
+        Create a chat client with registered tools.
+
+        This method creates a standalone chat client configured with the
+        specified tools and callbacks. Each call returns an independent client
+        instance with its own conversation state.
+
+        Parameters
+        ----------
+        tools
+            Which tools to include: `"update"`, `"query"`, or both. Can be:
+            - A single tool string: `"update"` or `"query"`
+            - A tuple of tools: `("update", "query")`
+            - `None` or `()` to skip adding any tools
+            - If not provided (default), uses the tools specified during initialization
+        update_dashboard
+            Optional callback function to call when the update_dashboard tool
+            succeeds. Takes a dict with `"query"` and `"title"` keys. Only used
+            if `"update"` is in tools.
+        reset_dashboard
+            Optional callback function to call when the `tool_reset_dashboard`
+            is invoked. Takes no arguments. Only used if `"update"` is in tools.
+
+        Returns
+        -------
+        chatlas.Chat
+            A configured chat client with tools registered based on the tools parameter.
+
+        Examples
+        --------
+        ```python
+        from querychat import QueryChat
+        import pandas as pd
+
+        df = pd.DataFrame({"a": [1, 2, 3]})
+        qc = QueryChat(df, "my_data")
+
+        # Create client with all tools (default)
+        client = qc.client()
+        response = client.chat("What's the average of column a?")
+
+        # Create client with only query tool (single string)
+        client = qc.client(tools="query")
+
+        # Create client with only query tool (tuple)
+        client = qc.client(tools=("query",))
+
+        # Create client with custom callbacks
+        from querychat import UpdateDashboardData
+
+
+        def my_update(data: UpdateDashboardData):
+            print(f"Query: {data['query']}, Title: {data['title']}")
+
+
+        client = qc.client(update_dashboard=my_update)
+        ```
+
+        """
+        tools = normalize_tools(tools, default=self.tools)
+
+        chat = copy.deepcopy(self._client)
+        chat.set_turns([])
+
+        chat.system_prompt = self._system_prompt.render(tools)
+
+        if tools is None:
+            return chat
+
+        if "update" in tools:
+            # Default callbacks that do nothing
+            update_fn = update_dashboard or (lambda _: None)
+            reset_fn = reset_dashboard or (lambda: None)
+
+            chat.register_tool(tool_update_dashboard(self._data_source, update_fn))
+            chat.register_tool(tool_reset_dashboard(reset_fn))
+
+        if "query" in tools:
+            chat.register_tool(tool_query(self._data_source))
+
+        return chat
+
+    def console(
+        self,
+        *,
+        new: bool = False,
+        tools: TOOL_GROUPS | tuple[TOOL_GROUPS, ...] | None = "query",
+        **kwargs,
+    ) -> None:
+        """
+        Launch an interactive console chat with the data.
+
+        This method provides a REPL (Read-Eval-Print Loop) interface for
+        chatting with your data from the command line. The console session
+        persists by default, so you can exit and return to continue your
+        conversation.
+
+        Parameters
+        ----------
+        new
+            If True, creates a new chat client and starts a fresh conversation.
+            If False (default), continues the conversation from the previous
+            console session.
+        tools
+            Which tools to include: "update", "query", or both. Can be:
+            - A single tool string: `"update"` or `"query"`
+            - A tuple of tools: `("update", "query")`
+            - `None` or `()` to skip adding any tools
+            - If not provided (default), defaults to `("query",)` only for
+              privacy (prevents the LLM from accessing data values)
+            Ignored if `new=False` and a console session already exists.
+        **kwargs
+            Additional arguments passed to the `client()` method when creating a
+            new client.
+
+        Examples
+        --------
+        ```python
+        from querychat import QueryChat
+        import pandas as pd
+
+        df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        qc = QueryChat(df, "my_data")
+
+        # Start console (query tool only by default)
+        qc.console()
+
+        # Start fresh console with all tools (using tuple)
+        qc.console(new=True, tools=("update", "query"))
+
+        # Start fresh console with all tools (using single string for one tool)
+        qc.console(new=True, tools="query")
+
+        # Continue previous console session
+        qc.console()  # picks up where you left off
+        ```
+
+        """
+        tools = normalize_tools(tools, default=("query",))
+
+        if new or self._client_console is None:
+            self._client_console = self.client(tools=tools, **kwargs)
+
+        self._client_console.console()
+
     @property
     def system_prompt(self) -> str:
         """
@@ -252,7 +424,7 @@ def system_prompt(self) -> str:
             The system prompt string.
 
         """
-        return self._client.system_prompt or ""
+        return self._system_prompt.render(self.tools)
 
     @property
     def data_source(self):
@@ -286,8 +458,13 @@ class QueryChat(QueryChatBase):
     """
     Create a QueryChat instance.
 
+    QueryChat enables natural language interaction with your data through an
+    LLM-powered chat interface. It can be used in Shiny applications, as a
+    standalone chat client, or in an interactive console.
+
     Examples
     --------
+    **Basic Shiny app:**
     ```python
     from querychat import QueryChat
 
@@ -295,6 +472,29 @@ class QueryChat(QueryChatBase):
     qc.app()
     ```
 
+    **Standalone chat client:**
+    ```python
+    from querychat import QueryChat
+    import pandas as pd
+
+    df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    qc = QueryChat(df, "my_data")
+
+    # Get a chat client with all tools
+    client = qc.client()
+    response = client.chat("What's the average of column a?")
+
+    # Start an interactive console chat
+    qc.console()
+    ```
+
+    **Privacy-focused mode:** Only allow dashboard filtering, ensuring the LLM
+    can't see any raw data.
+    ```python
+    qc = QueryChat(df, "my_data", tools="update")
+    qc.app()
+    ```
+
     Parameters
     ----------
     data_source
@@ -324,6 +524,19 @@ class QueryChat(QueryChatBase):
         If `client` is not provided, querychat consults the
         `QUERYCHAT_CLIENT` environment variable. If that is not set, it
         defaults to `"openai"`.
+    tools
+        Which querychat tools to include in the chat client by default. Can be:
+        - A single tool string: `"update"` or `"query"`
+        - A tuple of tools: `("update", "query")`
+        - `None` or `()` to disable all tools
+
+        Default is `("update", "query")` (both tools enabled).
+
+        Set to `"update"` to prevent the LLM from accessing data values, only
+        allowing dashboard filtering without answering questions.
+
+        The tools can be overridden per-client by passing a different `tools`
+        parameter to the `.client()` method.
     data_description
         Description of the data in plain text or Markdown. If a pathlib.Path
         object is passed, querychat will read the contents of the path into a
@@ -419,7 +632,7 @@ def title():
             self.id,
             data_source=self._data_source,
             greeting=self.greeting,
-            client=self._client,
+            client=self.client,
             enable_bookmarking=enable_bookmarking,
         )
 
@@ -648,19 +861,6 @@ def title(self, value: Optional[str] = None) -> str | None | bool:
         else:
             return self._vals.title.set(value)
 
-    @property
-    def client(self):
-        """
-        Get the (session-specific) chat client.
-
-        Returns
-        -------
-        :
-            The current chat client.
-
-        """
-        return self._vals.client
-
 
 def normalize_data_source(
     data_source: IntoFrame | sqlalchemy.Engine | DataSource,
@@ -731,3 +931,20 @@ def assemble_system_prompt(
             "extra_instructions": extra_instructions_str,
         },
     )
+
+
+def normalize_tools(
+    tools: TOOL_GROUPS | tuple[TOOL_GROUPS, ...] | None | MISSING_TYPE,
+    default: tuple[TOOL_GROUPS, ...] | None,
+) -> tuple[TOOL_GROUPS, ...] | None:
+    if tools is None or tools == ():
+        return None
+    elif isinstance(tools, MISSING_TYPE):
+        return default
+    elif isinstance(tools, str):
+        return (tools,)
+    elif isinstance(tools, tuple):
+        return tools
+    else:
+        # Convert any other sequence to tuple
+        return tuple(tools)
diff --git a/pkg-py/src/querychat/_querychat_module.py b/pkg-py/src/querychat/_querychat_module.py
index 26402584..f2bed066 100644
--- a/pkg-py/src/querychat/_querychat_module.py
+++ b/pkg-py/src/querychat/_querychat_module.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Union
 
+import chatlas
 import shinychat
 from shiny import module, reactive, ui
 
@@ -14,12 +15,12 @@
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    import chatlas
     import pandas as pd
     from shiny import Inputs, Outputs, Session
     from shiny.bookmark import BookmarkState, RestoreState
 
     from ._datasource import DataSource
+    from .types import UpdateDashboardData
 
 ReactiveString = reactive.Value[str]
 """A reactive string value."""
@@ -91,7 +92,7 @@ def mod_server(
     *,
     data_source: DataSource,
     greeting: str | None,
-    client: chatlas.Chat,
+    client: chatlas.Chat | Callable,
     enable_bookmarking: bool,
 ):
     # Reactive values to store state
@@ -99,18 +100,27 @@ def mod_server(
     title = ReactiveStringOrNone(None)
     has_greeted = reactive.value[bool](False)  # noqa: FBT003
 
-    # Set up the chat object for this session
-    chat = copy.deepcopy(client)
+    def update_dashboard(data: UpdateDashboardData):
+        sql.set(data["query"])
+        title.set(data["title"])
 
-    # Create the tool functions
-    update_dashboard_tool = tool_update_dashboard(data_source, sql, title)
-    reset_dashboard_tool = tool_reset_dashboard(sql, title)
-    query_tool = tool_query(data_source)
+    def reset_dashboard():
+        sql.set(None)
+        title.set(None)
 
-    # Register tools with annotations for the UI
-    chat.register_tool(update_dashboard_tool)
-    chat.register_tool(query_tool)
-    chat.register_tool(reset_dashboard_tool)
+    # Set up the chat object for this session
+    # Support both a callable that creates a client and legacy instance pattern
+    if callable(client) and not isinstance(client, chatlas.Chat):
+        chat = client(
+            update_dashboard=update_dashboard, reset_dashboard=reset_dashboard
+        )
+    else:
+        # Legacy pattern: client is Chat instance
+        chat = copy.deepcopy(client)
+
+        chat.register_tool(tool_update_dashboard(data_source, update_dashboard))
+        chat.register_tool(tool_query(data_source))
+        chat.register_tool(tool_reset_dashboard(reset_dashboard))
 
     # Execute query when SQL changes
     @reactive.calc
@@ -168,7 +178,7 @@ def _():
             title.set(new_title)
 
     if enable_bookmarking:
-        chat_ui.enable_bookmarking(client)
+        chat_ui.enable_bookmarking(chat)
 
         @session.bookmark.on_bookmark
         def _on_bookmark(x: BookmarkState) -> None:
diff --git a/pkg-py/src/querychat/_system_prompt.py b/pkg-py/src/querychat/_system_prompt.py
new file mode 100644
index 00000000..81936fb9
--- /dev/null
+++ b/pkg-py/src/querychat/_system_prompt.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import chevron
+
+if TYPE_CHECKING:
+    from ._datasource import DataSource
+    from ._querychat import TOOL_GROUPS
+
+
+class QueryChatSystemPrompt:
+    """Manages system prompt template and component assembly."""
+
+    def __init__(
+        self,
+        prompt_template: str | Path,
+        data_source: DataSource,
+        data_description: str | Path | None = None,
+        extra_instructions: str | Path | None = None,
+        categorical_threshold: int = 10,
+    ):
+        """
+        Initialize with prompt components.
+
+        Args:
+            prompt_template: Mustache template string or path to template file
+            data_source: DataSource instance for schema generation
+            data_description: Optional data context (string or path)
+            extra_instructions: Optional custom LLM instructions (string or path)
+            categorical_threshold: Threshold for categorical column detection
+
+        """
+        if isinstance(prompt_template, Path):
+            self.template = prompt_template.read_text()
+        else:
+            self.template = prompt_template
+
+        if isinstance(data_description, Path):
+            self.data_description = data_description.read_text()
+        else:
+            self.data_description = data_description
+
+        if isinstance(extra_instructions, Path):
+            self.extra_instructions = extra_instructions.read_text()
+        else:
+            self.extra_instructions = extra_instructions
+
+        self.schema = data_source.get_schema(
+            categorical_threshold=categorical_threshold
+        )
+
+        self.categorical_threshold = categorical_threshold
+        self.data_source = data_source
+
+    def render(self, tools: tuple[TOOL_GROUPS, ...] | None) -> str:
+        """
+        Render system prompt with tool configuration.
+
+        Args:
+            tools: Normalized tuple of tool groups to enable (already normalized by caller)
+
+        Returns:
+            Fully rendered system prompt string
+
+        """
+        is_duck_db = self.data_source.get_db_type().lower() == "duckdb"
+
+        context = {
+            "db_type": self.data_source.get_db_type(),
+            "is_duck_db": is_duck_db,
+            "schema": self.schema,
+            "data_description": self.data_description,
+            "extra_instructions": self.extra_instructions,
+            "has_tool_update": "update" in tools if tools else False,
+            "has_tool_query": "query" in tools if tools else False,
+        }
+
+        return chevron.render(self.template, context)
diff --git a/pkg-py/src/querychat/_utils.py b/pkg-py/src/querychat/_utils.py
index f24b3832..1d90dfd9 100644
--- a/pkg-py/src/querychat/_utils.py
+++ b/pkg-py/src/querychat/_utils.py
@@ -11,6 +11,15 @@
     from narwhals.stable.v1.typing import IntoFrame
 
 
+class MISSING_TYPE:  # noqa: N801
+    """
+    A singleton representing a missing value.
+    """
+
+
+MISSING = MISSING_TYPE()
+
+
 @contextmanager
 def temp_env_vars(env_vars: dict[str, Optional[str]]):
     """
diff --git a/pkg-py/src/querychat/prompts/prompt.md b/pkg-py/src/querychat/prompts/prompt.md
index 8dbb348c..be276d64 100644
--- a/pkg-py/src/querychat/prompts/prompt.md
+++ b/pkg-py/src/querychat/prompts/prompt.md
@@ -35,9 +35,10 @@ quantile_cont(salary, 0.5)
 {{/is_duck_db}}
 ## Your Capabilities
 
-You can handle three types of requests:
+You can handle these types of requests:
 
-### 1. Filtering and Sorting Data
+{{#has_tool_update}}
+### Filtering and Sorting Data
 
 When the user asks you to filter or sort the dashboard, e.g. "Show me..." or "Which ____ have the highest ____?" or "Filter to only include ____":
 
@@ -51,7 +52,16 @@ When the user asks you to filter or sort the dashboard, e.g. "Show me..." or "Wh
 
 The user may ask to "reset" or "start over"; that means clearing the filter and title. Do this by calling `querychat_reset_dashboard()`.
 
-### 2. Answering Questions About Data
+**Filtering Example:**
+User: "Show only rows where sales are above average"
+Tool Call: `querychat_update_dashboard({query: "SELECT * FROM table WHERE sales > (SELECT AVG(sales) FROM table)", title: "Above average sales"})`
+Response: ""
+
+No further response needed, the user will see the updated dashboard.
+
+{{/has_tool_update}}
+{{#has_tool_query}}
+### Answering Questions About Data
 
 When the user asks you a question about the data, e.g. "What is the average ____?" or "How many ____ are there?" or "Which ____ has the highest ____?":
 
@@ -61,7 +71,15 @@ When the user asks you a question about the data, e.g. "What is the average ____
 - Users can see your SQL queries and will ask you to explain the code if needed
 - If you cannot complete the request using SQL, politely decline and explain why
 
-### 3. Providing Suggestions for Next Steps
+**Question Example:**
+User: "What's the average revenue?"
+Tool Call: `querychat_query({query: "SELECT AVG(revenue) AS avg_revenue FROM table"})`
+Response: "The average revenue is $X."
+
+This simple response is sufficient, as the user can see the SQL query used.
+
+{{/has_tool_query}}
+### Providing Suggestions for Next Steps
 
 #### Suggestion Syntax
 
@@ -125,22 +143,6 @@ You might want to <span class="suggestion">explore the advanced features</span>
 - **Never pretend** you have access to data you don't actually have
 - **Use Markdown tables** for any tabular or structured data in your responses
 
-## Examples
-
-**Filtering Example:**
-User: "Show only rows where sales are above average"
-Tool Call: `querychat_update_dashboard({query: "SELECT * FROM table WHERE sales > (SELECT AVG(sales) FROM table)", title: "Above average sales"})`
-Response: ""
-
-No response needed, the user will see the updated dashboard.
-
-**Question Example:**
-User: "What's the average revenue?"
-Tool Call: `querychat_query({query: "SELECT AVG(revenue) AS avg_revenue FROM table"})`
-Response: "The average revenue is $X."
-
-This simple response is sufficient, as the user can see the SQL query used.
-
 {{#extra_instructions}}
 ## Additional Instructions
 
diff --git a/pkg-py/src/querychat/tools.py b/pkg-py/src/querychat/tools.py
index 72128713..e0001de1 100644
--- a/pkg-py/src/querychat/tools.py
+++ b/pkg-py/src/querychat/tools.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypedDict
 
 import chevron
 from chatlas import ContentToolResult, Tool
@@ -14,7 +14,45 @@
     from collections.abc import Callable
 
     from ._datasource import DataSource
-    from ._querychat_module import ReactiveStringOrNone
+
+
+class UpdateDashboardData(TypedDict):
+    """
+    Data passed to update_dashboard callback.
+
+    This TypedDict defines the structure of data passed to the
+    `tool_update_dashboard` callback function when the LLM requests an update to
+    the dashboard's data based on a SQL query.
+
+    Attributes
+    ----------
+    query
+        The SQL query string to execute for filtering/sorting the dashboard.
+    title
+        A descriptive title for the query, typically displayed in the UI.
+
+    Examples
+    --------
+    ```python
+    import pandas as pd
+    from querychat import QueryChat
+    from querychat.types import UpdateDashboardData
+
+
+    def log_update(data: UpdateDashboardData):
+        print(f"Executing: {data['query']}")
+        print(f"Title: {data['title']}")
+
+
+    df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    qc = QueryChat(df, "my_data")
+    client = qc.client(update_dashboard=log_update)
+    ```
+
+    """
+
+    query: str
+    title: str
 
 
 def _read_prompt_template(filename: str, **kwargs) -> str:
@@ -26,8 +64,7 @@ def _read_prompt_template(filename: str, **kwargs) -> str:
 
 def _update_dashboard_impl(
     data_source: DataSource,
-    current_query: ReactiveStringOrNone,
-    current_title: ReactiveStringOrNone,
+    update_fn: Callable[[UpdateDashboardData], None],
 ) -> Callable[[str, str], ContentToolResult]:
     """Create the implementation function for updating the dashboard."""
 
@@ -48,11 +85,8 @@ def update_dashboard(query: str, title: str) -> ContentToolResult:
                 Apply Filter
             </button>"""
 
-            # Update state on success
-            if query is not None:
-                current_query.set(query)
-            if title is not None:
-                current_title.set(title)
+            # Call the callback with TypedDict data on success
+            update_fn({"query": query, "title": title})
 
         except Exception as e:
             error = str(e)
@@ -78,8 +112,7 @@ def update_dashboard(query: str, title: str) -> ContentToolResult:
 
 def tool_update_dashboard(
     data_source: DataSource,
-    current_query: ReactiveStringOrNone,
-    current_title: ReactiveStringOrNone,
+    update_fn: Callable[[UpdateDashboardData], None],
 ) -> Tool:
     """
     Create a tool that modifies the data presented in the dashboard based on the SQL query.
@@ -88,10 +121,8 @@ def tool_update_dashboard(
     ----------
     data_source
         The data source to query against
-    current_query
-        Reactive value for storing the current SQL query
-    current_title
-        Reactive value for storing the current title
+    update_fn
+        Callback function to call with UpdateDashboardData when update succeeds
 
     Returns
     -------
@@ -99,7 +130,7 @@ def tool_update_dashboard(
         A tool that can be registered with chatlas
 
     """
-    impl = _update_dashboard_impl(data_source, current_query, current_title)
+    impl = _update_dashboard_impl(data_source, update_fn)
 
     description = _read_prompt_template(
         "tool-update-dashboard.md",
@@ -115,15 +146,13 @@ def tool_update_dashboard(
 
 
 def _reset_dashboard_impl(
-    current_query: ReactiveStringOrNone,
-    current_title: ReactiveStringOrNone,
+    reset_fn: Callable[[], None],
 ) -> Callable[[], ContentToolResult]:
     """Create the implementation function for resetting the dashboard."""
 
     def reset_dashboard() -> ContentToolResult:
-        # Reset current query and title
-        current_query.set(None)
-        current_title.set(None)
+        # Call the callback to reset
+        reset_fn()
 
         # Add Reset Filter button
         button_html = """<button
@@ -151,18 +180,15 @@ def reset_dashboard() -> ContentToolResult:
 
 
 def tool_reset_dashboard(
-    current_query: ReactiveStringOrNone,
-    current_title: ReactiveStringOrNone,
+    reset_fn: Callable[[], None],
 ) -> Tool:
     """
     Create a tool that resets the dashboard to show all data.
 
     Parameters
     ----------
-    current_query
-        Reactive value for storing the current SQL query
-    current_title
-        Reactive value for storing the current title
+    reset_fn
+        Callback function to call when reset is invoked
 
     Returns
     -------
@@ -170,7 +196,7 @@ def tool_reset_dashboard(
         A tool that can be registered with chatlas
 
     """
-    impl = _reset_dashboard_impl(current_query, current_title)
+    impl = _reset_dashboard_impl(reset_fn)
 
     description = _read_prompt_template("tool-reset-dashboard.md")
     impl.__doc__ = description
diff --git a/pkg-py/src/querychat/types/__init__.py b/pkg-py/src/querychat/types/__init__.py
index 339579a2..0e55bf1b 100644
--- a/pkg-py/src/querychat/types/__init__.py
+++ b/pkg-py/src/querychat/types/__init__.py
@@ -1,9 +1,11 @@
 from .._datasource import DataFrameSource, DataSource, SQLAlchemySource  # noqa: A005
 from .._querychat_module import ServerValues
+from ..tools import UpdateDashboardData
 
 __all__ = (
     "DataFrameSource",
     "DataSource",
     "SQLAlchemySource",
     "ServerValues",
+    "UpdateDashboardData",
 )
diff --git a/pkg-py/tests/test_client_console.py b/pkg-py/tests/test_client_console.py
new file mode 100644
index 00000000..06eaa895
--- /dev/null
+++ b/pkg-py/tests/test_client_console.py
@@ -0,0 +1,295 @@
+"""Tests for QueryChat.client() and QueryChat.console() methods."""
+
+import os
+from unittest.mock import patch
+
+import chatlas
+import pandas as pd
+import pytest
+from querychat import QueryChat
+from querychat.types import UpdateDashboardData
+
+
+@pytest.fixture(autouse=True)
+def set_dummy_api_key():
+    """Set a dummy OpenAI API key for testing."""
+    old_api_key = os.environ.get("OPENAI_API_KEY")
+    os.environ["OPENAI_API_KEY"] = "sk-dummy-api-key-for-testing"
+    yield
+    if old_api_key is not None:
+        os.environ["OPENAI_API_KEY"] = old_api_key
+    else:
+        del os.environ["OPENAI_API_KEY"]
+
+
+@pytest.fixture
+def sample_df():
+    """Create a sample pandas DataFrame for testing."""
+    return pd.DataFrame(
+        {
+            "id": [1, 2, 3],
+            "name": ["Alice", "Bob", "Charlie"],
+            "age": [25, 30, 35],
+            "salary": [50000, 60000, 70000],
+        },
+    )
+
+
+class TestClientMethod:
+    """Tests for QueryChat.client() method."""
+
+    def test_client_returns_chat_instance(self, sample_df):
+        """Test that client() returns a chatlas.Chat instance."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+        client = qc.client()
+
+        assert client is not None
+        assert hasattr(client, "chat")
+        assert hasattr(client, "register_tool")
+
+    def test_client_uses_default_tools(self, sample_df):
+        """Test that client() uses default tools from initialization."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+        client = qc.client()
+
+        # Check that system prompt includes both tool sections
+        prompt = client.system_prompt
+        assert "Filtering and Sorting Data" in prompt
+        assert "Answering Questions About Data" in prompt
+
+    def test_client_override_tools_query_only(self, sample_df):
+        """Test that client() can override tools to query-only."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+        client = qc.client(tools="query")
+
+        # Check that system prompt excludes update tool section
+        prompt = client.system_prompt
+        assert "Filtering and Sorting Data" not in prompt
+        assert "Answering Questions About Data" in prompt
+
+    def test_client_override_tools_update_only(self, sample_df):
+        """Test that client() can override tools to update-only."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+        client = qc.client(tools="update")
+
+        # Check that system prompt excludes query tool section
+        prompt = client.system_prompt
+        assert "Filtering and Sorting Data" in prompt
+        assert "Answering Questions About Data" not in prompt
+
+    def test_client_no_tools(self, sample_df):
+        """Test that client() can be created with no tools."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+        client = qc.client(tools=None)
+
+        prompt = client.system_prompt
+        # Should not include tool-specific sections
+        assert "Filtering and Sorting Data" not in prompt
+        assert "Answering Questions About Data" not in prompt
+
+    def test_client_independent_copies(self, sample_df):
+        """Test that each client() call returns independent instances."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+        client1 = qc.client()
+        client2 = qc.client()
+
+        # Should be different instances
+        assert client1 is not client2
+
+        # Modifying one shouldn't affect the other
+        client1.set_turns([{"role": "user", "content": "test"}])
+        assert len(client1.get_turns()) == 1
+        assert len(client2.get_turns()) == 0
+
+    def test_client_custom_update_callback(self, sample_df):
+        """Test that client() accepts custom update_dashboard callback."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+        callback_data = {}
+
+        def my_update(data: UpdateDashboardData):
+            callback_data["query"] = data["query"]
+            callback_data["title"] = data["title"]
+
+        client = qc.client(update_dashboard=my_update)
+
+        # Callback should be registered (we can't easily test execution without
+        # mocking the LLM, but we can verify the client was created)
+        assert client is not None
+
+    def test_client_custom_reset_callback(self, sample_df):
+        """Test that client() accepts custom reset_dashboard callback."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+        reset_called = {"called": False}
+
+        def my_reset():
+            reset_called["called"] = True
+
+        client = qc.client(reset_dashboard=my_reset)
+
+        # Callback should be registered
+        assert client is not None
+
+    def test_client_respects_initialization_tools(self, sample_df):
+        """Test that client() respects tools set at initialization."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!", tools="query")
+
+        # Should default to query-only
+        client = qc.client()
+        prompt = client.system_prompt
+
+        assert "Filtering and Sorting Data" not in prompt
+        assert "Answering Questions About Data" in prompt
+
+    def test_client_can_override_initialization_tools(self, sample_df):
+        """Test that client() can override tools set at initialization."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!", tools="query")
+
+        # Override to include update
+        client = qc.client(tools=("update", "query"))
+        prompt = client.system_prompt
+
+        assert "Filtering and Sorting Data" in prompt
+        assert "Answering Questions About Data" in prompt
+
+
+class TestConsoleMethod:
+    """Tests for QueryChat.console() method."""
+
+    def test_console_defaults_to_query_only(self, sample_df):
+        """Test that console() defaults to query-only tools."""
+        with patch.object(chatlas.Chat, "console"):
+            qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+            qc.console()
+
+            # Check the console client's system prompt
+            prompt = qc._client_console.system_prompt
+            assert "Filtering and Sorting Data" not in prompt
+            assert "Answering Questions About Data" in prompt
+
+    @patch.object(chatlas.Chat, "console")
+    def test_console_persists_across_calls(self, mock_console, sample_df):
+        """Test that console() persists the same client across calls."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+        qc.console()
+        first_client = qc._client_console
+
+        qc.console()
+        second_client = qc._client_console
+
+        # Should be the same instance
+        assert first_client is second_client
+
+        # Should have been called twice (once per console() call)
+        assert mock_console.call_count == 2  # noqa: PLR2004
+
+    def test_console_new_creates_fresh_client(self, sample_df):
+        """Test that console(new=True) creates a fresh client."""
+        with patch.object(chatlas.Chat, "console"):
+            qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+            qc.console()
+            first_client = qc._client_console
+
+            qc.console(new=True)
+            second_client = qc._client_console
+
+            # Should be different instances
+            assert first_client is not second_client
+
+    def test_console_can_specify_tools(self, sample_df):
+        """Test that console() can specify tools."""
+        with patch.object(chatlas.Chat, "console"):
+            qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+            qc.console(tools=("update", "query"))
+
+            # Check the console client includes both tools
+            prompt = qc._client_console.system_prompt
+            assert "Filtering and Sorting Data" in prompt
+            assert "Answering Questions About Data" in prompt
+
+
+class TestPromptConditionalSections:
+    """Tests for conditional tool sections in system prompt."""
+
+    def test_prompt_includes_both_tools_by_default(self, sample_df):
+        """Test that system prompt includes both tool sections by default."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+        prompt = qc.system_prompt
+
+        assert "Filtering and Sorting Data" in prompt
+        assert "Answering Questions About Data" in prompt
+        assert "querychat_update_dashboard" in prompt
+        assert "querychat_query" in prompt
+
+    def test_prompt_excludes_update_when_query_only(self, sample_df):
+        """Test that system prompt excludes update section with query-only tools."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!", tools="query")
+
+        prompt = qc.system_prompt
+
+        assert "Filtering and Sorting Data" not in prompt
+        assert "Answering Questions About Data" in prompt
+
+    def test_prompt_excludes_query_when_update_only(self, sample_df):
+        """Test that system prompt excludes query section with update-only tools."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!", tools="update")
+
+        prompt = qc.system_prompt
+
+        assert "Filtering and Sorting Data" in prompt
+        assert "Answering Questions About Data" not in prompt
+
+    def test_prompt_assembly_respects_client_tools(self, sample_df):
+        """Test that client() method respects tools parameter in system prompt."""
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+        # Test with query-only
+        client_query = qc.client(tools="query")
+        prompt_query = client_query.system_prompt
+        assert prompt_query is not None
+        assert "Answering Questions About Data" in prompt_query
+        assert "Filtering and Sorting Data" not in prompt_query
+
+        # Test with update-only
+        client_update = qc.client(tools="update")
+        prompt_update = client_update.system_prompt
+        assert prompt_update is not None
+        assert "Filtering and Sorting Data" in prompt_update
+        assert "Answering Questions About Data" not in prompt_update
+
+
+class TestBackwardCompatibility:
+    """Tests for backward compatibility with existing code."""
+
+    def test_default_tools_maintain_current_behavior(self, sample_df):
+        """Test that default tools parameter maintains current behavior."""
+        # Without tools parameter, should include both tools (like before)
+        qc = QueryChat(sample_df, "test_table", greeting="Hello!")
+
+        assert qc.tools == ("update", "query")
+
+        prompt = qc.system_prompt
+        assert "Filtering and Sorting Data" in prompt
+        assert "Answering Questions About Data" in prompt
+
+    def test_existing_initialization_still_works(self, sample_df):
+        """Test that existing QueryChat initialization patterns still work."""
+        # This should work exactly as before
+        qc = QueryChat(
+            data_source=sample_df,
+            table_name="test_table",
+            greeting="Hello!",
+            data_description="Test data",
+            extra_instructions="Test instructions",
+        )
+
+        assert qc is not None
+        assert qc.id == "test_table"
+        assert qc.tools == ("update", "query")
diff --git a/pkg-py/tests/test_system_prompt.py b/pkg-py/tests/test_system_prompt.py
new file mode 100644
index 00000000..8df49df9
--- /dev/null
+++ b/pkg-py/tests/test_system_prompt.py
@@ -0,0 +1,250 @@
+"""Unit tests for QueryChatSystemPrompt class."""
+
+import tempfile
+from pathlib import Path
+
+import pandas as pd
+import pytest
+from querychat._datasource import DataFrameSource
+from querychat._system_prompt import QueryChatSystemPrompt
+
+
+@pytest.fixture
+def sample_data_source():
+    """Create a sample DataFrameSource for testing."""
+    df = pd.DataFrame(
+        {
+            "id": [1, 2, 3],
+            "name": ["Alice", "Bob", "Charlie"],
+            "age": [25, 30, 35],
+        }
+    )
+    return DataFrameSource(df, "test_table")
+
+
+@pytest.fixture
+def sample_prompt_template():
+    """Create a sample prompt template for testing."""
+    return """Database Type: {{db_type}}
+Schema: {{schema}}
+{{#data_description}}Data: {{data_description}}{{/data_description}}
+{{#extra_instructions}}Instructions: {{extra_instructions}}{{/extra_instructions}}
+{{#has_tool_update}}UPDATE TOOL ENABLED{{/has_tool_update}}
+{{#has_tool_query}}QUERY TOOL ENABLED{{/has_tool_query}}"""
+
+
+class TestQueryChatSystemPromptInit:
+    """Tests for QueryChatSystemPrompt initialization."""
+
+    def test_init_with_string_template(
+        self, sample_data_source, sample_prompt_template
+    ):
+        """Test initialization with string template."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+        )
+
+        assert prompt.template == sample_prompt_template
+        assert prompt.data_source == sample_data_source
+        assert prompt.data_description is None
+        assert prompt.extra_instructions is None
+        assert prompt.schema is not None
+        assert prompt.categorical_threshold == 10  # noqa: PLR2004
+
+    def test_init_with_path_template(self, sample_data_source):
+        """Test initialization with Path template."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False) as f:
+            f.write("Template from file: {{db_type}}")
+            template_path = Path(f.name)
+
+        try:
+            prompt = QueryChatSystemPrompt(
+                prompt_template=template_path,
+                data_source=sample_data_source,
+            )
+
+            assert prompt.template == "Template from file: {{db_type}}"
+        finally:
+            template_path.unlink()
+
+    def test_init_with_string_data_description(
+        self, sample_data_source, sample_prompt_template
+    ):
+        """Test initialization with string data description."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+            data_description="This is test data",
+        )
+
+        assert prompt.data_description == "This is test data"
+
+    def test_init_with_path_data_description(
+        self, sample_data_source, sample_prompt_template
+    ):
+        """Test initialization with Path data description."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+            f.write("Data description from file")
+            desc_path = Path(f.name)
+
+        try:
+            prompt = QueryChatSystemPrompt(
+                prompt_template=sample_prompt_template,
+                data_source=sample_data_source,
+                data_description=desc_path,
+            )
+
+            assert prompt.data_description == "Data description from file"
+        finally:
+            desc_path.unlink()
+
+    def test_init_with_string_extra_instructions(
+        self, sample_data_source, sample_prompt_template
+    ):
+        """Test initialization with string extra instructions."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+            extra_instructions="Be concise",
+        )
+
+        assert prompt.extra_instructions == "Be concise"
+
+    def test_init_with_path_extra_instructions(
+        self, sample_data_source, sample_prompt_template
+    ):
+        """Test initialization with Path extra instructions."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+            f.write("Instructions from file")
+            instr_path = Path(f.name)
+
+        try:
+            prompt = QueryChatSystemPrompt(
+                prompt_template=sample_prompt_template,
+                data_source=sample_data_source,
+                extra_instructions=instr_path,
+            )
+
+            assert prompt.extra_instructions == "Instructions from file"
+        finally:
+            instr_path.unlink()
+
+    def test_init_with_custom_categorical_threshold(
+        self, sample_data_source, sample_prompt_template
+    ):
+        """Test initialization with custom categorical threshold."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+            categorical_threshold=15,
+        )
+
+        assert prompt.categorical_threshold == 15  # noqa: PLR2004
+
+
+class TestQueryChatSystemPromptRender:
+    """Tests for QueryChatSystemPrompt.render() method."""
+
+    def test_render_with_both_tools(self, sample_data_source, sample_prompt_template):
+        """Test rendering with both tools enabled."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+        )
+
+        rendered = prompt.render(tools=("update", "query"))
+
+        assert "UPDATE TOOL ENABLED" in rendered
+        assert "QUERY TOOL ENABLED" in rendered
+        assert "Database Type:" in rendered
+        assert "Schema:" in rendered
+
+    def test_render_with_query_only(self, sample_data_source, sample_prompt_template):
+        """Test rendering with only query tool enabled."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+        )
+
+        rendered = prompt.render(tools=("query",))
+
+        assert "UPDATE TOOL ENABLED" not in rendered
+        assert "QUERY TOOL ENABLED" in rendered
+
+    def test_render_with_update_only(self, sample_data_source, sample_prompt_template):
+        """Test rendering with only update tool enabled."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+        )
+
+        rendered = prompt.render(tools=("update",))
+
+        assert "UPDATE TOOL ENABLED" in rendered
+        assert "QUERY TOOL ENABLED" not in rendered
+
+    def test_render_with_no_tools(self, sample_data_source, sample_prompt_template):
+        """Test rendering with no tools enabled."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+        )
+
+        rendered = prompt.render(tools=None)
+
+        assert "UPDATE TOOL ENABLED" not in rendered
+        assert "QUERY TOOL ENABLED" not in rendered
+
+    def test_render_includes_data_description(
+        self, sample_data_source, sample_prompt_template
+    ):
+        """Test that rendering includes data description when provided."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+            data_description="Test data description",
+        )
+
+        rendered = prompt.render(tools=("query",))
+
+        assert "Data: Test data description" in rendered
+
+    def test_render_includes_extra_instructions(
+        self, sample_data_source, sample_prompt_template
+    ):
+        """Test that rendering includes extra instructions when provided."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+            extra_instructions="Be very concise",
+        )
+
+        rendered = prompt.render(tools=("query",))
+
+        assert "Instructions: Be very concise" in rendered
+
+    def test_render_includes_schema(self, sample_data_source, sample_prompt_template):
+        """Test that rendering includes schema information."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+        )
+
+        rendered = prompt.render(tools=("query",))
+
+        assert "Schema:" in rendered
+        # Schema should contain table information
+        assert prompt.schema in rendered
+
+    def test_render_includes_db_type(self, sample_data_source, sample_prompt_template):
+        """Test that rendering includes database type."""
+        prompt = QueryChatSystemPrompt(
+            prompt_template=sample_prompt_template,
+            data_source=sample_data_source,
+        )
+
+        rendered = prompt.render(tools=("query",))
+
+        assert "Database Type:" in rendered
+        assert sample_data_source.get_db_type() in rendered
diff --git a/pkg-r/NEWS.md b/pkg-r/NEWS.md
index c9b28036..64a8f6a3 100644
--- a/pkg-r/NEWS.md
+++ b/pkg-r/NEWS.md
@@ -1,5 +1,11 @@
 # querychat (development version)
 
+* `QueryChat$client()` can now create standalone querychat-enabled chat clients with configurable tools and callbacks, enabling use outside of Shiny applications. (#168)
+
+* `QueryChat$console()` was added to launch interactive console-based chat sessions with your data source, with persistent conversation state across invocations. (#168)
+
+* The tools used in a `QueryChat` chatbot are now configurable. Use the new `tools` parameter of `querychat()` or `QueryChat$new()` to select either or both `"query"` or `"update"` tools. Choose `tools = "update"` if you only want QueryChat to be able to update the dashboard (useful when you want to be 100% certain that the LLM will not see _any_ raw data). (#168)
+ 
 * `querychat_app()` will now only automatically clean up the data source if QueryChat creates the data source internally from a data frame. (#164)
 
 * **Breaking change:** The `$sql()` method now returns `NULL` instead of `""` (empty string) when no query has been set, aligning with the behavior of `$title()` for consistency. Most code using `isTruthy()` or similar falsy checks will continue working without changes. Code that explicitly checks `sql() == ""` should be updated to use falsy checks (e.g., `!isTruthy(sql())`) or explicit null checks (`is.null(sql())`). (#146)
diff --git a/pkg-r/R/DataSource.R b/pkg-r/R/DataSource.R
index dbade311..92a217c1 100644
--- a/pkg-r/R/DataSource.R
+++ b/pkg-r/R/DataSource.R
@@ -580,52 +580,3 @@ r_class_to_sql_type <- function(r_class) {
   )
 }
 # nocov end
-
-assemble_system_prompt <- function(
-  source,
-  data_description = NULL,
-  extra_instructions = NULL,
-  categorical_threshold = 20,
-  prompt_template = NULL
-) {
-  if (!is_data_source(source)) {
-    cli::cli_abort(
-      "{.arg source} must be a {.cls DataSource} object, not {.obj_type_friendly {source}}"
-    )
-  }
-
-  prompt_text <- read_text(
-    prompt_template %||%
-      system.file("prompts", "prompt.md", package = "querychat")
-  )
-
-  if (!is.null(data_description)) {
-    data_description <- read_text(data_description)
-  }
-  if (!is.null(extra_instructions)) {
-    extra_instructions <- read_text(extra_instructions)
-  }
-
-  schema <- source$get_schema(categorical_threshold = categorical_threshold)
-  db_type <- source$get_db_type()
-
-  whisker::whisker.render(
-    prompt_text,
-    list(
-      schema = schema,
-      data_description = data_description,
-      extra_instructions = extra_instructions,
-      db_type = db_type,
-      is_duck_db = identical(db_type, "DuckDB")
-    )
-  )
-}
-
-
-read_text <- function(x) {
-  if (file.exists(x)) {
-    read_utf8(x)
-  } else {
-    paste(x, collapse = "\n")
-  }
-}
diff --git a/pkg-r/R/QueryChat.R b/pkg-r/R/QueryChat.R
index 47e7338b..09199c95 100644
--- a/pkg-r/R/QueryChat.R
+++ b/pkg-r/R/QueryChat.R
@@ -67,13 +67,17 @@ QueryChat <- R6::R6Class(
   private = list(
     server_values = NULL,
     .data_source = NULL,
-    .client = NULL
+    .client = NULL,
+    .client_console = NULL,
+    .system_prompt = NULL
   ),
   public = list(
     #' @field greeting The greeting message displayed to users.
     greeting = NULL,
     #' @field id The module ID for namespacing.
     id = NULL,
+    #' @field tools The allowed tools for the chat client.
+    tools = c("update", "query"),
 
     #' @description
     #' Create a new QueryChat object.
@@ -100,6 +104,12 @@ QueryChat <- R6::R6Class(
     #'   - `NULL` (default): Uses the `querychat.client` option, the
     #'     `QUERYCHAT_CLIENT` environment variable, or defaults to
     #'     [ellmer::chat_openai()]
+    #' @param tools Which querychat tools to include in the chat client, by
+    #'   default. `"update"` includes the tools for updating and resetting the
+    #'   dashboard and `"query"` includes the tool for executing SQL queries.
+    #'   Use `tools = "update"` when you only want the dashboard updating tools,
+    #'   or when you want to disable the querying tool entirely to prevent the
+    #'   LLM from seeing any of the data in your dataset.
     #' @param data_description Optional description of the data in plain text or
     #'   Markdown. Can be a string or a file path. This provides context to the
     #'   LLM about what the data represents.
@@ -143,6 +153,7 @@ QueryChat <- R6::R6Class(
       id = NULL,
       greeting = NULL,
       client = NULL,
+      tools = c("update", "query"),
       data_description = NULL,
       categorical_threshold = 20,
       extra_instructions = NULL,
@@ -154,6 +165,7 @@ QueryChat <- R6::R6Class(
       # Validate arguments
       check_string(id, allow_null = TRUE)
       check_string(greeting, allow_null = TRUE)
+      arg_match(tools)
       check_string(data_description, allow_null = TRUE)
       check_number_whole(categorical_threshold, min = 1)
       check_string(extra_instructions, allow_null = TRUE)
@@ -167,25 +179,34 @@ QueryChat <- R6::R6Class(
       private$.data_source <- normalize_data_source(data_source, table_name)
 
       self$id <- id %||% table_name
+      self$tools <- tools
 
       if (!is.null(greeting) && file.exists(greeting)) {
         greeting <- read_utf8(greeting)
       }
       self$greeting <- greeting
 
-      prompt <- assemble_system_prompt(
-        private$.data_source,
+      # Create system prompt manager
+      if (is.null(prompt_template)) {
+        prompt_template <- system.file(
+          "prompts",
+          "prompt.md",
+          package = "querychat"
+        )
+      }
+
+      private$.system_prompt <- QueryChatSystemPrompt$new(
+        prompt_template = prompt_template,
+        data_source = private$.data_source,
         data_description = data_description,
-        categorical_threshold = categorical_threshold,
         extra_instructions = extra_instructions,
-        prompt_template = prompt_template
+        categorical_threshold = categorical_threshold
       )
 
       # Fork and empty chat now so the per-session forks are fast
       client <- as_querychat_client(client)
       private$.client <- client$clone()
       private$.client$set_turns(list())
-      private$.client$set_system_prompt(prompt)
 
       # By default, only close automatically if a Shiny session is active
       if (is.na(cleanup)) {
@@ -200,6 +221,77 @@ QueryChat <- R6::R6Class(
       }
     },
 
+    #' @description
+    #' Create a chat client, complete with registered tools, for the current
+    #' data source.
+    #'
+    #' @param tools Which querychat tools to include in the chat client.
+    #'   `"update"` includes the tools for updating and resetting the dashboard
+    #'   and `"query"` includes the tool for executing SQL queries. By default,
+    #'   when `tools = NA`, the values provided at initialization are used.
+    #' @param update_dashboard Optional function to call with the `query` and
+    #'   `title` generated by the LLM for the `update_dashboard` tool.
+    #' @param reset_dashboard Optional function to call when the
+    #'   `reset_dashboard` tool is called.
+    client = function(
+      tools = NA,
+      update_dashboard = function(query, title) {},
+      reset_dashboard = function() {}
+    ) {
+      if (is_na(tools)) {
+        tools <- self$tools
+      }
+      if (!is.null(tools)) {
+        tools <- arg_match(
+          tools,
+          values = c("update", "query"),
+          multiple = TRUE
+        )
+      }
+
+      chat <- private$.client$clone()
+      chat$set_system_prompt(private$.system_prompt$render(tools = tools))
+
+      if (is.null(tools)) {
+        return(chat)
+      }
+
+      if ("update" %in% tools) {
+        chat$register_tool(
+          tool_update_dashboard(
+            private$.data_source,
+            update_fn = update_dashboard
+          )
+        )
+        chat$register_tool(tool_reset_dashboard(reset_dashboard))
+      }
+
+      if ("query" %in% tools) {
+        chat$register_tool(tool_query(private$.data_source))
+      }
+
+      chat
+    },
+
+    #' @description
+    #' Launch a console-based chat interface with the data source.
+    #'
+    #' @param new Whether to create a new chat client instance or continue the
+    #'   conversation from the last console chat session (the default).
+    #' @param ... Additional arguments passed to the `$client()` method.
+    #' @param tools Which querychat tools to include in the chat client. See
+    #'   `$client()` for details. Ignored when not creating a new chat client.
+    #'   By default, only the `"query"` tool is included, regardless of the
+    #'   `tools` set at initialization.
+    console = function(new = FALSE, ..., tools = "query") {
+      check_bool(new)
+      if (new || is.null(private$.client_console)) {
+        private$.client_console <- self$client(tools = tools, ...)
+      }
+
+      ellmer::live_console(private$.client_console)
+    },
+
     #' @description
     #' Create and run a Shiny gadget for chatting with data
     #'
@@ -475,7 +567,7 @@ QueryChat <- R6::R6Class(
         self$id,
         data_source = private$.data_source,
         greeting = self$greeting,
-        client = private$.client,
+        client = self$client,
         enable_bookmarking = enable_bookmarking
       )
     },
@@ -484,9 +576,9 @@ QueryChat <- R6::R6Class(
     #' Generate a welcome greeting for the chat.
     #'
     #' By default, `QueryChat$new()` generates a greeting at the start of every
-    #' new conversation, which is convenient for getting started and development,
-    #' but also might add unnecessary latency and cost. Use this method to
-    #' generate a greeting once and save it for reuse.
+    #' new conversation, which is convenient for getting started and
+    #' development, but also might add unnecessary latency and cost. Use this
+    #' method to generate a greeting once and save it for reuse.
     #'
     #' @param echo Whether to print the greeting to the console. Options are
     #'   `"none"` (default, no output) or `"output"` (print to console).
@@ -506,7 +598,7 @@ QueryChat <- R6::R6Class(
     #' qc2 <- QueryChat$new(mtcars, greeting = "mtcars_greeting.md")
     #' }
     generate_greeting = function(echo = c("none", "output")) {
-      chat <- private$.client$clone()
+      chat <- self$client()
       chat$set_turns(list())
 
       as.character(chat$chat(GREETING_PROMPT, echo = echo))
@@ -533,7 +625,7 @@ QueryChat <- R6::R6Class(
   active = list(
     #' @field system_prompt Get the system prompt.
     system_prompt = function() {
-      private$.client$get_system_prompt()
+      private$.system_prompt$render(tools = self$tools)
     },
 
     #' @field data_source Get the current data source.
@@ -570,6 +662,12 @@ QueryChat <- R6::R6Class(
 #'   - `NULL` (default): Uses the `querychat.client` option, the
 #'     `QUERYCHAT_CLIENT` environment variable, or defaults to
 #'     [ellmer::chat_openai()]
+#' @param tools Which querychat tools to include in the chat client, by
+#'   default. `"update"` includes the tools for updating and resetting the
+#'   dashboard and `"query"` includes the tool for executing SQL queries.
+#'   Use `tools = "update"` when you only want the dashboard updating tools,
+#'   or when you want to disable the querying tool entirely to prevent the
+#'   LLM from seeing any of the data in your dataset.
 #' @param data_description Optional description of the data in plain text or
 #'   Markdown. Can be a string or a file path. This provides context to the
 #'   LLM about what the data represents.
@@ -625,6 +723,7 @@ querychat <- function(
   id = NULL,
   greeting = NULL,
   client = NULL,
+  tools = c("update", "query"),
   data_description = NULL,
   categorical_threshold = 20,
   extra_instructions = NULL,
@@ -642,6 +741,7 @@ querychat <- function(
     id = id,
     greeting = greeting,
     client = client,
+    tools = tools,
     data_description = data_description,
     categorical_threshold = categorical_threshold,
     extra_instructions = extra_instructions,
@@ -664,6 +764,7 @@ querychat_app <- function(
   id = NULL,
   greeting = NULL,
   client = NULL,
+  tools = c("update", "query"),
   data_description = NULL,
   categorical_threshold = 20,
   extra_instructions = NULL,
@@ -695,6 +796,7 @@ querychat_app <- function(
     id = id,
     greeting = greeting,
     client = client,
+    tools = tools,
     data_description = data_description,
     categorical_threshold = categorical_threshold,
     extra_instructions = extra_instructions,
diff --git a/pkg-r/R/QueryChatSystemPrompt.R b/pkg-r/R/QueryChatSystemPrompt.R
new file mode 100644
index 00000000..4f40c472
--- /dev/null
+++ b/pkg-r/R/QueryChatSystemPrompt.R
@@ -0,0 +1,106 @@
+#' System Prompt Management for QueryChat
+#'
+#' @description
+#' `QueryChatSystemPrompt` is an R6 class that encapsulates system prompt
+#' template and component management for QueryChat. It handles loading of
+#' prompt templates, data descriptions, and extra instructions from files or
+#' strings, and renders them with tool configuration using Mustache templates.
+#'
+#' @noRd
+QueryChatSystemPrompt <- R6::R6Class(
+  "QueryChatSystemPrompt",
+
+  public = list(
+    #' @field template The Mustache template string for the system prompt, or
+    #'   a path to a file containing a system prompt template.
+    template = NULL,
+
+    #' @field data_description Optional description of the data context, or a
+    #'   path to a file containing the data description.
+    data_description = NULL,
+
+    #' @field extra_instructions Optional custom instructions for the LLM, or a
+    #'   path to a file containing the extra instructions.
+    extra_instructions = NULL,
+
+    #' @field schema The database schema information.
+    schema = NULL,
+
+    #' @field categorical_threshold Threshold for categorical column detection.
+    categorical_threshold = NULL,
+
+    #' @field data_source Reference to the data source object.
+    data_source = NULL,
+
+    #' @description
+    #' Create a new QueryChatSystemPrompt object.
+    #'
+    #' @param prompt_template Path to template file or template string.
+    #' @param data_source A DataSource object for schema access.
+    #' @param data_description Optional path to data description file or description string.
+    #' @param extra_instructions Optional path to instructions file or instructions string.
+    #' @param categorical_threshold Threshold for categorical column detection (default: 10).
+    #'
+    #' @return A new `QueryChatSystemPrompt` object.
+    initialize = function(
+      prompt_template,
+      data_source,
+      data_description = NULL,
+      extra_instructions = NULL,
+      categorical_threshold = 10
+    ) {
+      # Load template (file or string) using helper
+      self$template <- read_text(prompt_template)
+
+      # Load data_description (file, string, or NULL)
+      if (!is.null(data_description)) {
+        self$data_description <- read_text(data_description)
+      }
+
+      # Load extra_instructions (file, string, or NULL)
+      if (!is.null(extra_instructions)) {
+        self$extra_instructions <- read_text(extra_instructions)
+      }
+
+      # Store schema and other fields
+      self$schema <- data_source$get_schema(
+        categorical_threshold = categorical_threshold
+      )
+      self$categorical_threshold <- categorical_threshold
+      self$data_source <- data_source
+    },
+
+    #' @description
+    #' Render the system prompt with tool configuration.
+    #'
+    #' @param tools Character vector of tool names to enable (e.g.,
+    #'   `c("query", "update"))`, or `NULL` for no tools.
+    #'
+    #' @return A character string containing the rendered system prompt.
+    render = function(tools) {
+      # Build context for whisker rendering
+      is_duck_db <- tolower(self$data_source$get_db_type()) == "duckdb"
+
+      context <- list(
+        db_type = self$data_source$get_db_type(),
+        is_duck_db = is_duck_db,
+        schema = self$schema,
+        data_description = self$data_description,
+        extra_instructions = self$extra_instructions,
+        has_tool_update = if ("update" %in% tools) "true",
+        has_tool_query = if ("query" %in% tools) "true"
+      )
+
+      whisker::whisker.render(self$template, context)
+    }
+  )
+)
+
+# Utility function for loading file or string content
+read_text <- function(x) {
+  if (file.exists(x)) {
+    read_utf8(x)
+  } else {
+    paste(x, collapse = "\n")
+  }
+}
diff --git a/pkg-r/R/querychat_module.R b/pkg-r/R/querychat_module.R
index ab3f19cf..3d977d1d 100644
--- a/pkg-r/R/querychat_module.R
+++ b/pkg-r/R/querychat_module.R
@@ -46,6 +46,15 @@ mod_server <- function(
       )
     }
 
+    update_dashboard <- function(query, title) {
+      if (!is.null(query)) {
+        current_query(query)
+      }
+      if (!is.null(title)) {
+        current_title(title)
+      }
+    }
+
     reset_query <- function() {
       current_query(NULL)
       current_title(NULL)
@@ -53,12 +62,21 @@ mod_server <- function(
     }
 
     # Set up the chat object for this session
-    chat <- client$clone()
-    chat$register_tool(
-      tool_update_dashboard(data_source, current_query, current_title)
-    )
-    chat$register_tool(tool_query(data_source))
-    chat$register_tool(tool_reset_dashboard(reset_query))
+    if (is_function(client)) {
+      # This is the `QueryChat$client` function, or generally a function that
+      # takes the update/reset callbacks and returns a realized QC chat client
+      chat <- client(
+        update_dashboard = update_dashboard,
+        reset_dashboard = reset_query
+      )
+    } else {
+      chat <- client$clone()
+      chat$register_tool(
+        tool_update_dashboard(data_source, update_fn = update_dashboard)
+      )
+      chat$register_tool(tool_query(data_source))
+      chat$register_tool(tool_reset_dashboard(reset_query))
+    }
 
     # Prepopulate the chat UI with a welcome message that appears to be from the
     # chat model (but is actually hard-coded). This is just for the user, not for
@@ -137,5 +155,5 @@ mod_server <- function(
   })
 }
 
-
+# TODO: Make this dependent on enabled tools
 GREETING_PROMPT <- "Please give me a friendly greeting. Include a few sample prompts in a two-level bulleted list."
diff --git a/pkg-r/R/querychat_tools.R b/pkg-r/R/querychat_tools.R
index 7ad43377..96fd435c 100644
--- a/pkg-r/R/querychat_tools.R
+++ b/pkg-r/R/querychat_tools.R
@@ -5,13 +5,26 @@
 #   summarizing the intent of the SQL query.
 tool_update_dashboard <- function(
   data_source,
-  current_query,
-  current_title
+  update_fn = function(query, title) {}
 ) {
+  check_data_source(data_source)
+
+  check_function(update_fn)
+  has_args <- intersect(fn_fmls_names(update_fn), c("query", "title"))
+  if (length(has_args) != 2) {
+    missing_args <- setdiff(c("query", "title"), has_args)
+    cli::cli_abort(
+      c(
+        "{.arg update_fn} must accept at least two named arguments: {.val query} and {.val title}.",
+        "x" = "{.val {missing_args}} argument{?s} {?was/were} missing."
+      )
+    )
+  }
+
   db_type <- data_source$get_db_type()
 
   ellmer::tool(
-    tool_update_dashboard_impl(data_source, current_query, current_title),
+    tool_update_dashboard_impl(data_source, update_fn),
     name = "querychat_update_dashboard",
     description = interpolate_package(
       "tool-update-dashboard.md",
@@ -35,11 +48,7 @@ tool_update_dashboard <- function(
   )
 }
 
-tool_update_dashboard_impl <- function(
-  data_source,
-  current_query,
-  current_title
-) {
+tool_update_dashboard_impl <- function(data_source, update_fn) {
   force(data_source)
 
   function(query, title) {
@@ -51,12 +60,7 @@ tool_update_dashboard_impl <- function(
     )
 
     if (is.null(res@error)) {
-      if (!is.null(query)) {
-        current_query(query)
-      }
-      if (!is.null(title)) {
-        current_title(title)
-      }
+      update_fn(query, title)
     }
 
     res
@@ -64,7 +68,9 @@ tool_update_dashboard_impl <- function(
 }
 
 
-tool_reset_dashboard <- function(reset_fn) {
+tool_reset_dashboard <- function(reset_fn = identity) {
+  check_function(reset_fn)
+
   ellmer::tool(
     reset_fn,
     name = "querychat_reset_dashboard",
@@ -81,7 +87,8 @@ tool_reset_dashboard <- function(reset_fn) {
 # @param query A SQL query; must be a SELECT statement.
 # @return The results of the query as a data frame.
 tool_query <- function(data_source) {
-  force(data_source)
+  check_data_source(data_source)
+
   db_type <- data_source$get_db_type()
 
   ellmer::tool(
diff --git a/pkg-r/R/utils-check.R b/pkg-r/R/utils-check.R
index 862b61ed..5982c8f9 100644
--- a/pkg-r/R/utils-check.R
+++ b/pkg-r/R/utils-check.R
@@ -1,3 +1,18 @@
+check_data_source <- function(
+  x,
+  ...,
+  arg = caller_arg(x),
+  call = caller_env()
+) {
+  if (!inherits(x, "DataSource")) {
+    cli::cli_abort(
+      "{.arg {arg}} must be a {.cls DataSource} object, not {.obj_type_friendly {x}}.",
+      call = call
+    )
+  }
+}
+
+
 # SQL table name validation ----------------------------------------------
 
 #' Check SQL table name validity
diff --git a/pkg-r/inst/prompts/prompt.md b/pkg-r/inst/prompts/prompt.md
index 8dbb348c..be276d64 100644
--- a/pkg-r/inst/prompts/prompt.md
+++ b/pkg-r/inst/prompts/prompt.md
@@ -35,9 +35,10 @@ quantile_cont(salary, 0.5)
 {{/is_duck_db}}
 ## Your Capabilities
 
-You can handle three types of requests:
+You can handle these types of requests:
 
-### 1. Filtering and Sorting Data
+{{#has_tool_update}}
+### Filtering and Sorting Data
 
 When the user asks you to filter or sort the dashboard, e.g. "Show me..." or "Which ____ have the highest ____?" or "Filter to only include ____":
 
@@ -51,7 +52,16 @@ When the user asks you to filter or sort the dashboard, e.g. "Show me..." or "Wh
 
 The user may ask to "reset" or "start over"; that means clearing the filter and title. Do this by calling `querychat_reset_dashboard()`.
 
-### 2. Answering Questions About Data
+**Filtering Example:**
+User: "Show only rows where sales are above average"
+Tool Call: `querychat_update_dashboard({query: "SELECT * FROM table WHERE sales > (SELECT AVG(sales) FROM table)", title: "Above average sales"})`
+Response: ""
+
+No further response needed, the user will see the updated dashboard.
+
+{{/has_tool_update}}
+{{#has_tool_query}}
+### Answering Questions About Data
 
 When the user asks you a question about the data, e.g. "What is the average ____?" or "How many ____ are there?" or "Which ____ has the highest ____?":
 
@@ -61,7 +71,15 @@ When the user asks you a question about the data, e.g. "What is the average ____
 - Users can see your SQL queries and will ask you to explain the code if needed
 - If you cannot complete the request using SQL, politely decline and explain why
 
-### 3. Providing Suggestions for Next Steps
+**Question Example:**
+User: "What's the average revenue?"
+Tool Call: `querychat_query({query: "SELECT AVG(revenue) AS avg_revenue FROM table"})`
+Response: "The average revenue is $X."
+
+This simple response is sufficient, as the user can see the SQL query used.
+
+{{/has_tool_query}}
+### Providing Suggestions for Next Steps
 
 #### Suggestion Syntax
 
@@ -125,22 +143,6 @@ You might want to <span class="suggestion">explore the advanced features</span>
 - **Never pretend** you have access to data you don't actually have
 - **Use Markdown tables** for any tabular or structured data in your responses
 
-## Examples
-
-**Filtering Example:**
-User: "Show only rows where sales are above average"
-Tool Call: `querychat_update_dashboard({query: "SELECT * FROM table WHERE sales > (SELECT AVG(sales) FROM table)", title: "Above average sales"})`
-Response: ""
-
-No response needed, the user will see the updated dashboard.
-
-**Question Example:**
-User: "What's the average revenue?"
-Tool Call: `querychat_query({query: "SELECT AVG(revenue) AS avg_revenue FROM table"})`
-Response: "The average revenue is $X."
-
-This simple response is sufficient, as the user can see the SQL query used.
-
 {{#extra_instructions}}
 ## Additional Instructions
 
diff --git a/pkg-r/man/QueryChat.Rd b/pkg-r/man/QueryChat.Rd
index ef747a96..58236f15 100644
--- a/pkg-r/man/QueryChat.Rd
+++ b/pkg-r/man/QueryChat.Rd
@@ -179,6 +179,8 @@ qc2 <- QueryChat$new(mtcars, greeting = "mtcars_greeting.md")
 \item{\code{greeting}}{The greeting message displayed to users.}
 
 \item{\code{id}}{The module ID for namespacing.}
+
+\item{\code{tools}}{The allowed tools for the chat client.}
 }
 \if{html}{\out{</div>}}
 }
@@ -195,6 +197,8 @@ qc2 <- QueryChat$new(mtcars, greeting = "mtcars_greeting.md")
 \subsection{Public methods}{
 \itemize{
 \item \href{#method-QueryChat-new}{\code{QueryChat$new()}}
+\item \href{#method-QueryChat-client}{\code{QueryChat$client()}}
+\item \href{#method-QueryChat-console}{\code{QueryChat$console()}}
 \item \href{#method-QueryChat-app}{\code{QueryChat$app()}}
 \item \href{#method-QueryChat-app_obj}{\code{QueryChat$app_obj()}}
 \item \href{#method-QueryChat-sidebar}{\code{QueryChat$sidebar()}}
@@ -218,6 +222,7 @@ Create a new QueryChat object.
   id = NULL,
   greeting = NULL,
   client = NULL,
+  tools = c("update", "query"),
   data_description = NULL,
   categorical_threshold = 20,
   extra_instructions = NULL,
@@ -259,6 +264,13 @@ a greeting to save and reuse.}
 \code{\link[ellmer:chat_openai]{ellmer::chat_openai()}}
 }}
 
+\item{\code{tools}}{Which querychat tools to include in the chat client, by
+default. \code{"update"} includes the tools for updating and resetting the
+dashboard and \code{"query"} includes the tool for executing SQL queries.
+Use \code{tools = "update"} when you only want the dashboard updating tools,
+or when you want to disable the querying tool entirely to prevent the
+LLM from seeing any of the data in your dataset.}
+
 \item{\code{data_description}}{Optional description of the data in plain text or
 Markdown. Can be a string or a file path. This provides context to the
 LLM about what the data represents.}
@@ -308,6 +320,64 @@ qc <- QueryChat$new(conn, "mtcars")
 
 }
 
+}
+\if{html}{\out{<hr>}}
+\if{html}{\out{<a id="method-QueryChat-client"></a>}}
+\if{latex}{\out{\hypertarget{method-QueryChat-client}{}}}
+\subsection{Method \code{client()}}{
+Create a chat client, complete with registered tools, for the current
+data source.
+\subsection{Usage}{
+\if{html}{\out{<div class="r">}}\preformatted{QueryChat$client(
+  tools = NA,
+  update_dashboard = function(query, title) {
+ },
+  reset_dashboard = function() {
+ }
+)}\if{html}{\out{</div>}}
+}
+
+\subsection{Arguments}{
+\if{html}{\out{<div class="arguments">}}
+\describe{
+\item{\code{tools}}{Which querychat tools to include in the chat client.
+\code{"update"} includes the tools for updating and resetting the dashboard
+and \code{"query"} includes the tool for executing SQL queries. By default,
+when \code{tools = NA}, the values provided at initialization are used.}
+
+\item{\code{update_dashboard}}{Optional function to call with the \code{query} and
+\code{title} generated by the LLM for the \code{update_dashboard} tool.}
+
+\item{\code{reset_dashboard}}{Optional function to call when the
+\code{reset_dashboard} tool is called.}
+}
+\if{html}{\out{</div>}}
+}
+}
+\if{html}{\out{<hr>}}
+\if{html}{\out{<a id="method-QueryChat-console"></a>}}
+\if{latex}{\out{\hypertarget{method-QueryChat-console}{}}}
+\subsection{Method \code{console()}}{
+Launch a console-based chat interface with the data source.
+\subsection{Usage}{
+\if{html}{\out{<div class="r">}}\preformatted{QueryChat$console(new = FALSE, ..., tools = "query")}\if{html}{\out{</div>}}
+}
+
+\subsection{Arguments}{
+\if{html}{\out{<div class="arguments">}}
+\describe{
+\item{\code{new}}{Whether to create a new chat client instance or continue the
+conversation from the last console chat session (the default).}
+
+\item{\code{...}}{Additional arguments passed to the \verb{$client()} method.}
+
+\item{\code{tools}}{Which querychat tools to include in the chat client. See
+\verb{$client()} for details. Ignored when not creating a new chat client.
+By default, only the \code{"query"} tool is included, regardless of the
+\code{tools} set at initialization.}
+}
+\if{html}{\out{</div>}}
+}
 }
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-QueryChat-app"></a>}}
@@ -552,9 +622,9 @@ server <- function(input, output, session) {
 Generate a welcome greeting for the chat.
 
 By default, \code{QueryChat$new()} generates a greeting at the start of every
-new conversation, which is convenient for getting started and development,
-but also might add unnecessary latency and cost. Use this method to
-generate a greeting once and save it for reuse.
+new conversation, which is convenient for getting started and
+development, but also might add unnecessary latency and cost. Use this
+method to generate a greeting once and save it for reuse.
 \subsection{Usage}{
 \if{html}{\out{<div class="r">}}\preformatted{QueryChat$generate_greeting(echo = c("none", "output"))}\if{html}{\out{</div>}}
 }
diff --git a/pkg-r/man/querychat-convenience.Rd b/pkg-r/man/querychat-convenience.Rd
index 2e176f08..fd4410da 100644
--- a/pkg-r/man/querychat-convenience.Rd
+++ b/pkg-r/man/querychat-convenience.Rd
@@ -12,6 +12,7 @@ querychat(
   id = NULL,
   greeting = NULL,
   client = NULL,
+  tools = c("update", "query"),
   data_description = NULL,
   categorical_threshold = 20,
   extra_instructions = NULL,
@@ -26,6 +27,7 @@ querychat_app(
   id = NULL,
   greeting = NULL,
   client = NULL,
+  tools = c("update", "query"),
   data_description = NULL,
   categorical_threshold = 20,
   extra_instructions = NULL,
@@ -65,6 +67,13 @@ a greeting to save and reuse.}
 \code{\link[ellmer:chat_openai]{ellmer::chat_openai()}}
 }}
 
+\item{tools}{Which querychat tools to include in the chat client, by
+default. \code{"update"} includes the tools for updating and resetting the
+dashboard and \code{"query"} includes the tool for executing SQL queries.
+Use \code{tools = "update"} when you only want the dashboard updating tools,
+or when you want to disable the querying tool entirely to prevent the
+LLM from seeing any of the data in your dataset.}
+
 \item{data_description}{Optional description of the data in plain text or
 Markdown. Can be a string or a file path. This provides context to the
 LLM about what the data represents.}
diff --git a/pkg-r/tests/testthat/_snaps/DataSource.md b/pkg-r/tests/testthat/_snaps/DataSource.md
index b6aa126a..70d79b18 100644
--- a/pkg-r/tests/testthat/_snaps/DataSource.md
+++ b/pkg-r/tests/testthat/_snaps/DataSource.md
@@ -163,19 +163,3 @@
       ! Table "`non_existent_table`" not found in database
       i If you're using a table in a catalog or schema, pass a `DBI::Id()` object to `table_name`
 
-# assemble_system_prompt() / errors with non-DataSource input
-
-    Code
-      assemble_system_prompt(list(not = "a data source"), data_description = "Test")
-    Condition
-      Error in `assemble_system_prompt()`:
-      ! `source` must be a <DataSource> object, not a list
-
----
-
-    Code
-      assemble_system_prompt(data.frame(x = 1:3), data_description = "Test")
-    Condition
-      Error in `assemble_system_prompt()`:
-      ! `source` must be a <DataSource> object, not a data frame
-
diff --git a/pkg-r/tests/testthat/_snaps/querychat_tools.md b/pkg-r/tests/testthat/_snaps/querychat_tools.md
new file mode 100644
index 00000000..eea808c3
--- /dev/null
+++ b/pkg-r/tests/testthat/_snaps/querychat_tools.md
@@ -0,0 +1,44 @@
+# tool_update_dashboard() checks inputs
+
+    Code
+      tool_update_dashboard("foo")
+    Condition
+      Error in `tool_update_dashboard()`:
+      ! `data_source` must be a <DataSource> object, not a string.
+
+---
+
+    Code
+      tool_update_dashboard(df_source, update_fn = NULL)
+    Condition
+      Error in `tool_update_dashboard()`:
+      ! `update_fn` must be a function, not `NULL`.
+    Code
+      tool_update_dashboard(df_source, update_fn = function(query) { })
+    Condition
+      Error in `tool_update_dashboard()`:
+      ! `update_fn` must accept at least two named arguments: "query" and "title".
+      x "title" argument was missing.
+    Code
+      tool_update_dashboard(df_source, update_fn = function(title, extra) { })
+    Condition
+      Error in `tool_update_dashboard()`:
+      ! `update_fn` must accept at least two named arguments: "query" and "title".
+      x "query" argument was missing.
+
+# tool_reset_dashboard() checks inputs
+
+    Code
+      tool_reset_dashboard("not_a_function")
+    Condition
+      Error in `tool_reset_dashboard()`:
+      ! `reset_fn` must be a function, not the string "not_a_function".
+
+# tool_query() checks inputs
+
+    Code
+      tool_query("invalid_source")
+    Condition
+      Error in `tool_query()`:
+      ! `data_source` must be a <DataSource> object, not a string.
+
diff --git a/pkg-r/tests/testthat/helper-fixtures.R b/pkg-r/tests/testthat/helper-fixtures.R
index 3c1e9a44..d9478e65 100644
--- a/pkg-r/tests/testthat/helper-fixtures.R
+++ b/pkg-r/tests/testthat/helper-fixtures.R
@@ -81,3 +81,29 @@ local_data_frame_source <- function(
   withr::defer(df_source$cleanup(), envir = env)
   df_source
 }
+
+local_querychat <- function(
+  data_source = new_test_df(),
+  table_name = "test_table",
+  ...,
+  env = parent.frame()
+) {
+  qc <- QueryChat$new(data_source, table_name, ...)
+  withr::defer(qc$cleanup(), envir = env)
+  qc
+}
+
+mock_ellmer_chat_client <- function(
+  public = list(),
+  private = list(),
+  env = parent.frame()
+) {
+  MockChat <- R6::R6Class(
+    "MockChat",
+    inherit = asNamespace("ellmer")[["Chat"]],
+    public = public,
+    private = private
+  )
+
+  MockChat$new(ellmer::Provider("test", "test", "test"))
+}
diff --git a/pkg-r/tests/testthat/test-DataSource.R b/pkg-r/tests/testthat/test-DataSource.R
index 51c7f007..e386b2fa 100644
--- a/pkg-r/tests/testthat/test-DataSource.R
+++ b/pkg-r/tests/testthat/test-DataSource.R
@@ -151,115 +151,6 @@ describe("DataSource$get_schema()", {
   })
 })
 
-describe("assemble_system_prompt()", {
-  df_source <- local_data_frame_source(new_test_df(3))
-
-  it("generates appropriate system prompt", {
-    prompt <- assemble_system_prompt(
-      df_source,
-      data_description = "A test dataframe"
-    )
-    expect_type(prompt, "character")
-    expect_true(nchar(prompt) > 0)
-    expect_match(prompt, "A test dataframe")
-    expect_match(prompt, "Table: test_table")
-  })
-
-  it("uses db_type to customize prompt template", {
-    sys_prompt <- assemble_system_prompt(df_source)
-
-    expect_equal(df_source$get_db_type(), "DuckDB")
-    expect_true(grepl("DuckDB SQL Tips", sys_prompt, fixed = TRUE))
-  })
-
-  it("errors with non-DataSource input", {
-    expect_snapshot(error = TRUE, {
-      assemble_system_prompt(
-        list(not = "a data source"),
-        data_description = "Test"
-      )
-    })
-
-    expect_snapshot(error = TRUE, {
-      assemble_system_prompt(
-        data.frame(x = 1:3),
-        data_description = "Test"
-      )
-    })
-  })
-
-  it("works without extra_instructions", {
-    prompt <- assemble_system_prompt(
-      df_source,
-      data_description = "A test dataframe",
-      extra_instructions = NULL
-    )
-
-    expect_type(prompt, "character")
-    expect_true(nchar(prompt) > 0)
-    expect_match(prompt, "A test dataframe")
-    expect_match(prompt, "Table: test_table")
-  })
-
-  it("accepts file paths for data_description", {
-    temp_file <- withr::local_tempfile(fileext = ".txt")
-    writeLines("This is a description from a file", temp_file)
-
-    prompt <- assemble_system_prompt(
-      df_source,
-      data_description = temp_file
-    )
-
-    expect_type(prompt, "character")
-    expect_match(prompt, "This is a description from a file")
-  })
-
-  it("accepts file paths for extra_instructions", {
-    temp_file <- withr::local_tempfile(fileext = ".txt")
-    writeLines("Extra instructions from file", temp_file)
-
-    prompt <- assemble_system_prompt(
-      df_source,
-      extra_instructions = temp_file
-    )
-
-    expect_type(prompt, "character")
-    expect_match(prompt, "Extra instructions from file")
-  })
-
-  it("accepts inline text for data_description", {
-    prompt <- assemble_system_prompt(
-      df_source,
-      data_description = "Inline description text"
-    )
-
-    expect_type(prompt, "character")
-    expect_match(prompt, "Inline description text")
-  })
-
-  it("accepts inline text for extra_instructions", {
-    prompt <- assemble_system_prompt(
-      df_source,
-      extra_instructions = "Inline extra instructions"
-    )
-
-    expect_type(prompt, "character")
-    expect_match(prompt, "Inline extra instructions")
-  })
-
-  it("works with both description and instructions as inline text", {
-    prompt <- assemble_system_prompt(
-      df_source,
-      data_description = "Description here",
-      extra_instructions = "Instructions here"
-    )
-
-    expect_type(prompt, "character")
-    expect_match(prompt, "Description here")
-    expect_match(prompt, "Instructions here")
-  })
-})
-
 describe("DataSource$get_db_type()", {
   it("returns DuckDB for DataFrameSource", {
     df_source <- local_data_frame_source(new_test_df())
diff --git a/pkg-r/tests/testthat/test-QueryChat.R b/pkg-r/tests/testthat/test-QueryChat.R
index 526a41b6..9db979de 100644
--- a/pkg-r/tests/testthat/test-QueryChat.R
+++ b/pkg-r/tests/testthat/test-QueryChat.R
@@ -170,6 +170,64 @@ describe("QueryChat$system_prompt", {
     # Should contain table name
     expect_true(grepl("test_df", prompt, fixed = TRUE))
   })
+
+  it("doesn't include update instructions if not enabled", {
+    template <- "{{#has_tool_update}}update tool enabled!{{/has_tool_update}}"
+
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df",
+      tools = "query",
+      prompt_template = template
+    )
+    withr::defer(qc$cleanup())
+
+    expect_equal(qc$system_prompt, "")
+  })
+
+  it("doesn't include query instructions if not enabled", {
+    template <- "{{#has_tool_query}}query tool enabled!{{/has_tool_query}}"
+
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df",
+      tools = "update",
+      prompt_template = template
+    )
+    withr::defer(qc$cleanup())
+
+    expect_equal(qc$system_prompt, "")
+  })
+
+  it("doesn't include update instructions if not enabled (full prompt)", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df",
+      tools = "query"
+    )
+    withr::defer(qc$cleanup())
+
+    tool_header <- "Filtering and Sorting Data"
+
+    expect_no_match(qc$system_prompt, tool_header)
+    expect_no_match(qc$client()$get_system_prompt(), tool_header)
+    expect_match(qc$client(tools = "update")$get_system_prompt(), tool_header)
+  })
+
+  it("doesn't include query instructions if not enabled (full prompt)", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df",
+      tools = "update"
+    )
+    withr::defer(qc$cleanup())
+
+    tool_header <- "Answering Questions About Data"
+
+    expect_no_match(qc$system_prompt, tool_header)
+    expect_no_match(qc$client()$get_system_prompt(), tool_header)
+    expect_match(qc$client(tools = "query")$get_system_prompt(), tool_header)
+  })
 })
 
 describe("QueryChat$data_source", {
@@ -186,10 +244,201 @@ describe("QueryChat$data_source", {
   })
 })
 
+describe("QueryChat$client()", {
+  it("uses default tools when tools = NA", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df",
+      tools = c("update", "query")
+    )
+    withr::defer(qc$cleanup())
+
+    client <- qc$client(tools = NA)
+
+    # Should have both update and query tools
+    tool_names <- sapply(client$get_tools(), function(t) t@name)
+    expect_contains(tool_names, "querychat_update_dashboard")
+    expect_contains(tool_names, "querychat_reset_dashboard")
+    expect_contains(tool_names, "querychat_query")
+  })
+
+  it("overrides default tools when tools parameter is provided", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df",
+      tools = c("update", "query")
+    )
+    withr::defer(qc$cleanup())
+
+    client <- qc$client(tools = "query")
+
+    # Should only have query tool
+    tool_names <- sapply(client$get_tools(), function(t) t@name)
+    expect_contains(tool_names, "querychat_query")
+    expect_false("querychat_update_dashboard" %in% tool_names)
+    expect_false("querychat_reset_dashboard" %in% tool_names)
+  })
+
+  it("registers only update tools when tools = 'update'", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df"
+    )
+    withr::defer(qc$cleanup())
+
+    client <- qc$client(tools = "update")
+
+    tool_names <- sapply(client$get_tools(), function(t) t@name)
+    expect_contains(tool_names, "querychat_update_dashboard")
+    expect_contains(tool_names, "querychat_reset_dashboard")
+    expect_false("querychat_query" %in% tool_names)
+  })
+
+  it("registers only query tool when tools = 'query'", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df"
+    )
+    withr::defer(qc$cleanup())
+
+    client <- qc$client(tools = "query")
+
+    tool_names <- sapply(client$get_tools(), function(t) t@name)
+    expect_contains(tool_names, "querychat_query")
+    expect_false("querychat_update_dashboard" %in% tool_names)
+    expect_false("querychat_reset_dashboard" %in% tool_names)
+  })
+
+  it("returns client with no tools when tools = NULL", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df"
+    )
+    withr::defer(qc$cleanup())
+
+    client <- qc$client(tools = NULL)
+
+    expect_length(client$get_tools(), 0)
+  })
+
+  it("sets system prompt based on tools parameter", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df"
+    )
+    withr::defer(qc$cleanup())
+
+    client_query <- qc$client(tools = "query")
+    client_update <- qc$client(tools = "update")
+
+    prompt_query <- client_query$get_system_prompt()
+    prompt_update <- client_update$get_system_prompt()
+
+    # Query client should have query instructions but not update
+    expect_match(prompt_query, "Answering Questions About Data")
+    expect_no_match(prompt_query, "Filtering and Sorting Data")
+
+    # Update client should have update instructions but not query
+    expect_match(prompt_update, "Filtering and Sorting Data")
+    expect_no_match(prompt_update, "Answering Questions About Data")
+  })
+
+  it("passes update_dashboard callback to tool", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df"
+    )
+    withr::defer(qc$cleanup())
+
+    update_calls <- list()
+    client <- qc$client(
+      tools = "update",
+      update_dashboard = function(query, title) {
+        update_calls <<- list(query = query, title = title)
+      }
+    )
+
+    # Find and call the update tool
+    tools <- client$get_tools()
+    update_tool <- tools[[which(sapply(tools, function(t) {
+      t@name == "querychat_update_dashboard"
+    }))]]
+
+    # Call the tool - it should execute the query and call the callback
+    result <- update_tool(
+      query = "SELECT * FROM test_df WHERE id = 1",
+      title = "Test Filter"
+    )
+
+    expect_null(result@error)
+    expect_equal(update_calls$query, "SELECT * FROM test_df WHERE id = 1")
+    expect_equal(update_calls$title, "Test Filter")
+  })
+
+  it("passes reset_dashboard callback to tool", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df"
+    )
+    withr::defer(qc$cleanup())
+
+    reset_called <- FALSE
+    client <- qc$client(
+      tools = "update",
+      reset_dashboard = function() {
+        reset_called <<- TRUE
+      }
+    )
+
+    # Find and call the reset tool
+    tools <- client$get_tools()
+    reset_tool <- tools[[which(sapply(tools, function(t) {
+      t@name == "querychat_reset_dashboard"
+    }))]]
+
+    # Call the tool
+    reset_tool()
+
+    expect_true(reset_called)
+  })
+
+  it("returns independent client instances on each call", {
+    qc <- QueryChat$new(
+      new_test_df(),
+      "test_df"
+    )
+    withr::defer(qc$cleanup())
+
+    client1 <- qc$client()
+    client2 <- qc$client()
+
+    # Should be different objects
+    expect_false(identical(client1, client2))
+
+    # Modifying one shouldn't affect the other
+    client1$set_turns(list(ellmer::Turn("user", "test message")))
+    expect_length(client1$get_turns(), 1)
+    expect_length(client2$get_turns(), 0)
+  })
+
+  it("respects QueryChat initialization tools by default", {
+    qc_query_only <- QueryChat$new(
+      new_test_df(),
+      "test_df",
+      tools = "query"
+    )
+    withr::defer(qc_query_only$cleanup())
+
+    client <- qc_query_only$client()
+    tool_names <- sapply(client$get_tools(), function(t) t@name)
+
+    expect_contains(tool_names, "querychat_query")
+    expect_false("querychat_update_dashboard" %in% tool_names)
+  })
+})
+
 test_that("QueryChat$generate_greeting() generates a greeting using the LLM client", {
-  MockChat <- R6::R6Class(
-    "MockChat",
-    inherit = asNamespace("ellmer")[["Chat"]],
+  client <- mock_ellmer_chat_client(
     public = list(
       chat = function(message, ...) {
         expect_equal(message, GREETING_PROMPT)
@@ -199,7 +448,6 @@ test_that("QueryChat$generate_greeting() generates a greeting using the LLM clie
   )
 
   test_df <- new_test_df()
-  client <- MockChat$new(ellmer::Provider("test", "test", "test"))
 
   # Create a mock client that returns a fixed greeting
   qc <- QueryChat$new(test_df, client = client)
@@ -261,6 +509,93 @@ describe("querychat()", {
   })
 })
 
+describe("QueryChat$console()", {
+  local_mocked_r6_class(
+    QueryChat,
+    public = list(
+      get_client_console = function() {
+        private$.client_console
+      }
+    )
+  )
+
+  it("defaults to query-only tools (privacy-focused)", {
+    qc <- local_querychat()
+
+    live_console_called <- FALSE
+    local_mocked_bindings(
+      live_console = function(chat) {
+        live_console_called <<- TRUE
+      },
+      .package = "ellmer"
+    )
+
+    qc$console()
+    expect_true(live_console_called)
+
+    console_client <- qc$get_client_console()
+    expect_s3_class(console_client, "Chat")
+
+    tools <- console_client$get_tools()
+    expect_equal(names(tools), "querychat_query")
+  })
+
+  it("persists console client across calls", {
+    qc <- local_querychat()
+
+    # Track live_console calls
+    live_console_call_count <- 0
+    local_mocked_bindings(
+      live_console = function(chat) {
+        live_console_call_count <<- live_console_call_count + 1
+      },
+      .package = "ellmer"
+    )
+
+    qc$console()
+    first_client <- qc$get_client_console()
+
+    qc$console()
+    second_client <- qc$get_client_console()
+
+    expect_identical(first_client, second_client)
+    expect_equal(live_console_call_count, 2)
+  })
+
+  it("creates fresh client when `new = TRUE`", {
+    qc <- local_querychat()
+    local_mocked_bindings(live_console = identity, .package = "ellmer")
+
+    qc$console()
+    first_client <- qc$get_client_console()
+
+    qc$console(new = TRUE)
+    second_client <- qc$get_client_console()
+
+    expect_false(identical(first_client, second_client))
+  })
+
+  it("allows overriding tools via `tools` parameter", {
+    qc <- local_querychat()
+    local_mocked_bindings(live_console = identity, .package = "ellmer")
+
+    qc$console(tools = c("update", "query"))
+
+    console_client <- qc$get_client_console()
+    expect_s3_class(console_client, "Chat")
+
+    tools <- console_client$get_tools()
+    expect_setequal(
+      names(tools),
+      c(
+        "querychat_query",
+        "querychat_update_dashboard",
+        "querychat_reset_dashboard"
+      )
+    )
+  })
+})
+
 describe("normalize_data_source()", {
   it("returns DataSource objects unchanged", {
     test_df <- new_test_df()
diff --git a/pkg-r/tests/testthat/test-QueryChatSystemPrompt.R b/pkg-r/tests/testthat/test-QueryChatSystemPrompt.R
new file mode 100644
index 00000000..f781a3f9
--- /dev/null
+++ b/pkg-r/tests/testthat/test-QueryChatSystemPrompt.R
@@ -0,0 +1,447 @@
+describe("QueryChatSystemPrompt$new()", {
+  it("initializes with string template", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Template: {{schema}}",
+      data_source = ds
+    )
+
+    expect_type(sp$template, "character")
+    expect_true(grepl("Template:", sp$template))
+    expect_type(sp$schema, "character")
+    expect_equal(sp$categorical_threshold, 10)
+  })
+
+  it("initializes with file path template", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    temp_file <- withr::local_tempfile(fileext = ".md")
+    writeLines("File template: {{db_type}}", temp_file)
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = temp_file,
+      data_source = ds
+    )
+
+    expect_type(sp$template, "character")
+    expect_true(grepl("File template:", sp$template))
+  })
+
+  it("initializes with string data_description", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Template",
+      data_source = ds,
+      data_description = "Test data description"
+    )
+
+    expect_equal(sp$data_description, "Test data description")
+  })
+
+  it("initializes with file path data_description", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    temp_file <- withr::local_tempfile(fileext = ".txt")
+    writeLines("Data from file", temp_file)
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Template",
+      data_source = ds,
+      data_description = temp_file
+    )
+
+    expect_equal(trimws(sp$data_description), "Data from file")
+  })
+
+  it("initializes with string extra_instructions", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Template",
+      data_source = ds,
+      extra_instructions = "Extra instructions here"
+    )
+
+    expect_equal(sp$extra_instructions, "Extra instructions here")
+  })
+
+  it("initializes with file path extra_instructions", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    temp_file <- withr::local_tempfile(fileext = ".txt")
+    writeLines("Instructions from file", temp_file)
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Template",
+      data_source = ds,
+      extra_instructions = temp_file
+    )
+
+    expect_equal(trimws(sp$extra_instructions), "Instructions from file")
+  })
+
+  it("stores categorical_threshold", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Template",
+      data_source = ds,
+      categorical_threshold = 25
+    )
+
+    expect_equal(sp$categorical_threshold, 25)
+  })
+
+  it("handles NULL data_description and extra_instructions", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Template",
+      data_source = ds
+    )
+
+    expect_null(sp$data_description)
+    expect_null(sp$extra_instructions)
+  })
+})
+
+describe("QueryChatSystemPrompt$render()", {
+  it("renders with both tools", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- paste(
+      "{{#has_tool_update}}update enabled{{/has_tool_update}}",
+      "{{#has_tool_query}}query enabled{{/has_tool_query}}",
+      sep = "\n"
+    )
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds
+    )
+
+    result <- sp$render(c("update", "query"))
+
+    expect_true(grepl("update enabled", result))
+    expect_true(grepl("query enabled", result))
+  })
+
+  it("renders with query only", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- paste(
+      "{{#has_tool_update}}update enabled{{/has_tool_update}}",
+      "{{#has_tool_query}}query enabled{{/has_tool_query}}",
+      sep = "\n"
+    )
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds
+    )
+
+    result <- sp$render("query")
+
+    expect_false(grepl("update enabled", result))
+    expect_true(grepl("query enabled", result))
+  })
+
+  it("renders with update only", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- paste(
+      "{{#has_tool_update}}update enabled{{/has_tool_update}}",
+      "{{#has_tool_query}}query enabled{{/has_tool_query}}",
+      sep = "\n"
+    )
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds
+    )
+
+    result <- sp$render("update")
+
+    expect_true(grepl("update enabled", result))
+    expect_false(grepl("query enabled", result))
+  })
+
+  it("renders with NULL tools", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- paste(
+      "{{#has_tool_update}}update enabled{{/has_tool_update}}",
+      "{{#has_tool_query}}query enabled{{/has_tool_query}}",
+      "Always shown",
+      sep = "\n"
+    )
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds
+    )
+
+    result <- sp$render(NULL)
+
+    expect_false(grepl("update enabled", result))
+    expect_false(grepl("query enabled", result))
+    expect_true(grepl("Always shown", result))
+  })
+
+  it("includes schema in rendered output", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Schema: {{schema}}",
+      data_source = ds
+    )
+
+    result <- sp$render(NULL)
+
+    expect_true(grepl("Schema:", result))
+    expect_true(grepl("test_table", result))
+  })
+
+  it("includes db_type in rendered output", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Database: {{db_type}}",
+      data_source = ds
+    )
+
+    result <- sp$render(NULL)
+
+    expect_true(grepl("Database:", result))
+    expect_true(grepl("DuckDB", result))
+  })
+
+  it("includes data_description when provided", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- paste(
+      "{{#data_description}}Description: {{data_description}}{{/data_description}}",
+      sep = "\n"
+    )
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds,
+      data_description = "My test data"
+    )
+
+    result <- sp$render(NULL)
+
+    expect_true(grepl("Description: My test data", result))
+  })
+
+  it("excludes data_description when NULL", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- paste(
+      "{{#data_description}}Description: {{data_description}}{{/data_description}}",
+      "Other content",
+      sep = "\n"
+    )
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds
+    )
+
+    result <- sp$render(NULL)
+
+    expect_false(grepl("Description:", result))
+    expect_true(grepl("Other content", result))
+  })
+
+  it("includes extra_instructions when provided", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- paste(
+      "{{#extra_instructions}}Instructions: {{extra_instructions}}{{/extra_instructions}}",
+      sep = "\n"
+    )
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds,
+      extra_instructions = "Be concise"
+    )
+
+    result <- sp$render(NULL)
+
+    expect_true(grepl("Instructions: Be concise", result))
+  })
+
+  it("excludes extra_instructions when NULL", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- paste(
+      "{{#extra_instructions}}Instructions: {{extra_instructions}}{{/extra_instructions}}",
+      "Other content",
+      sep = "\n"
+    )
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds
+    )
+
+    result <- sp$render(NULL)
+
+    expect_false(grepl("Instructions:", result))
+    expect_true(grepl("Other content", result))
+  })
+
+  it("detects DuckDB correctly", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    template <- "{{#is_duck_db}}DuckDB detected{{/is_duck_db}}"
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = template,
+      data_source = ds
+    )
+
+    result <- sp$render(NULL)
+
+    # DataFrameSource uses DuckDB under the hood
+    expect_true(grepl("DuckDB detected", result))
+  })
+
+  it("returns character string", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = "Simple template",
+      data_source = ds
+    )
+
+    result <- sp$render(NULL)
+
+    expect_type(result, "character")
+    expect_true(nchar(result) > 0)
+  })
+})
+
+describe("QueryChatSystemPrompt with full prompt.md template", {
+  it("renders full template with data_description", {
+    df <- new_test_df(3)
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = system.file(
+        "prompts",
+        "prompt.md",
+        package = "querychat"
+      ),
+      data_source = ds,
+      data_description = "A test dataframe"
+    )
+    prompt <- sp$render(NULL)
+
+    expect_type(prompt, "character")
+    expect_true(nchar(prompt) > 0)
+    expect_match(prompt, "A test dataframe")
+    expect_match(prompt, "Table: test_table")
+  })
+
+  it("includes DuckDB-specific content for DuckDB sources", {
+    df <- new_test_df()
+    ds <- DataFrameSource$new(df, "test_table")
+    withr::defer(ds$cleanup())
+
+    sp <- QueryChatSystemPrompt$new(
+      prompt_template = system.file(
+        "prompts",
+        "prompt.md",
+        package = "querychat"
+      ),
+      data_source = ds
+    )
+    sys_prompt <- sp$render(NULL)
+
+    expect_equal(ds$get_db_type(), "DuckDB")
+    expect_true(grepl("DuckDB SQL Tips", sys_prompt, fixed = TRUE))
+  })
+
+  it("handles categorical_threshold with full template", {
+    # Create a source with categorical data
+    df_with_categories <- data.frame(
+      id = 1:10,
+      category = rep(c("A", "B", "C", "D", "E"), each = 2)
+    )
+    cat_source <- DataFrameSource$new(df_with_categories, "test_table")
+    withr::defer(cat_source$cleanup())
+
+    # With low threshold, categories should not be listed
+    sp_low <- QueryChatSystemPrompt$new(
+      prompt_template = system.file(
+        "prompts",
+        "prompt.md",
+        package = "querychat"
+      ),
+      data_source = cat_source,
+      categorical_threshold = 3
+    )
+    prompt_low <- sp_low$render(NULL)
+    expect_false(grepl("Categorical values:", prompt_low))
+
+    # With high threshold, categories should be listed
+    sp_high <- QueryChatSystemPrompt$new(
+      prompt_template = system.file(
+        "prompts",
+        "prompt.md",
+        package = "querychat"
+      ),
+      data_source = cat_source,
+      categorical_threshold = 10
+    )
+    prompt_high <- sp_high$render(NULL)
+    expect_match(prompt_high, "Categorical values:")
+  })
+})
diff --git a/pkg-r/tests/testthat/test-querychat_tools.R b/pkg-r/tests/testthat/test-querychat_tools.R
index 784db691..8c43b838 100644
--- a/pkg-r/tests/testthat/test-querychat_tools.R
+++ b/pkg-r/tests/testthat/test-querychat_tools.R
@@ -1,3 +1,22 @@
+test_that("tool_update_dashboard() checks inputs", {
+  expect_snapshot(error = TRUE, tool_update_dashboard("foo"))
+
+  df_source <- local_data_frame_source(new_test_df())
+  expect_snapshot(error = TRUE, {
+    tool_update_dashboard(df_source, update_fn = NULL)
+    tool_update_dashboard(df_source, update_fn = function(query) {})
+    tool_update_dashboard(df_source, update_fn = function(title, extra) {})
+  })
+})
+
+test_that("tool_reset_dashboard() checks inputs", {
+  expect_snapshot(error = TRUE, tool_reset_dashboard("not_a_function"))
+})
+
+test_that("tool_query() checks inputs", {
+  expect_snapshot(error = TRUE, tool_query("invalid_source"))
+})
+
 describe("querychat_tool_starts_open()", {
   it("uses the tool default when options are unset", {
     withr::local_options(querychat.tool_details = NULL)
@@ -295,10 +314,8 @@ describe("tool_query()", {
 describe("tool_update_dashboard()", {
   it("returns an ellmer tool object", {
     df_source <- local_data_frame_source(new_test_df())
-    current_query <- shiny::reactiveVal("SELECT * FROM test_table")
-    current_title <- shiny::reactiveVal("All Data")
 
-    tool <- tool_update_dashboard(df_source, current_query, current_title)
+    tool <- tool_update_dashboard(df_source)
 
     expect_s3_class(tool, "ellmer::ToolDef")
     expect_equal(tool@name, "querychat_update_dashboard")
@@ -306,35 +323,29 @@ describe("tool_update_dashboard()", {
 
   it("includes database type in description", {
     df_source <- local_data_frame_source(new_test_df())
-    current_query <- shiny::reactiveVal("SELECT * FROM test_table")
-    current_title <- shiny::reactiveVal("All Data")
 
-    tool <- tool_update_dashboard(df_source, current_query, current_title)
+    tool <- tool_update_dashboard(df_source)
 
     # DataFrameSource uses DuckDB
     expect_match(tool@description, "DuckDB|duckdb", ignore.case = TRUE)
   })
 
   it("creates a working tool function", {
-    shiny::testServer(
-      app = function(input, output, session) {
-        current_query <- shiny::reactiveVal("SELECT * FROM test_table")
-        current_title <- shiny::reactiveVal("All Data")
-
-        df_source <- local_data_frame_source(new_test_df())
-        tool <- tool_update_dashboard(df_source, current_query, current_title)
-
-        result <- tool(
-          query = "SELECT * FROM test_table WHERE id > 2",
-          title = "Filtered View"
-        )
-      },
-      expr = {
-        expect_s7_class(result, ellmer::ContentToolResult)
-        expect_equal(current_query(), "SELECT * FROM test_table WHERE id > 2")
-        expect_equal(current_title(), "Filtered View")
-      }
+    df_source <- local_data_frame_source(new_test_df())
+
+    res_update <- NULL
+    tool <- tool_update_dashboard(df_source, function(query, title) {
+      res_update <<- list(query = query, title = title)
+    })
+
+    res_tool <- tool(
+      query = "SELECT * FROM test_table WHERE id > 2",
+      title = "Filtered View"
     )
+
+    expect_s7_class(res_tool, ellmer::ContentToolResult)
+    expect_equal(res_update$query, "SELECT * FROM test_table WHERE id > 2")
+    expect_equal(res_update$title, "Filtered View")
   })
 })
 
@@ -364,11 +375,7 @@ describe("tool_update_dashboard_impl()", {
     current_query <- shiny::reactiveVal("SELECT * FROM test_table")
     current_title <- shiny::reactiveVal("All Data")
 
-    impl_fn <- tool_update_dashboard_impl(
-      df_source,
-      current_query,
-      current_title
-    )
+    impl_fn <- tool_update_dashboard_impl(df_source)
 
     expect_type(impl_fn, "closure")
   })
@@ -376,106 +383,37 @@ describe("tool_update_dashboard_impl()", {
   it("updates reactive values on successful query", {
     df_source <- local_data_frame_source(new_test_df())
 
-    shiny::testServer(
-      app = function(input, output, session) {
-        current_query <- shiny::reactiveVal("SELECT * FROM test_table")
-        current_title <- shiny::reactiveVal("All Data")
-
-        impl_fn <- tool_update_dashboard_impl(
-          df_source,
-          current_query,
-          current_title
-        )
-
-        result <- impl_fn(
-          query = "SELECT * FROM test_table WHERE id < 3",
-          title = "First Two"
-        )
-      },
-      expr = {
-        expect_equal(current_query(), "SELECT * FROM test_table WHERE id < 3")
-        expect_equal(current_title(), "First Two")
-        expect_null(result@error)
-      }
+    res_update <- NULL
+    impl_fn <- tool_update_dashboard_impl(df_source, function(query, title) {
+      res_update <<- list(query = query, title = title)
+    })
+
+    res_tool <- impl_fn(
+      query = "SELECT * FROM test_table WHERE id < 3",
+      title = "First Two"
     )
+
+    expect_equal(res_update$query, "SELECT * FROM test_table WHERE id < 3")
+    expect_equal(res_update$title, "First Two")
+    expect_null(res_tool@error)
   })
 
   it("does not update reactive values on query error", {
-    shiny::testServer(
-      app = function(input, output, session) {
-        df_source <- local_data_frame_source(new_test_df())
-        current_query <- shiny::reactiveVal("SELECT * FROM test_table")
-        current_title <- shiny::reactiveVal("All Data")
-
-        tool <- tool_update_dashboard_impl(
-          df_source,
-          current_query,
-          current_title
-        )
-
-        result <- tool(
-          query = "INVALID SQL",
-          title = "Should Not Update"
-        )
-      },
-      expr = {
-        # Values should remain unchanged
-        expect_equal(current_query(), "SELECT * FROM test_table")
-        expect_equal(current_title(), "All Data")
-        expect_s3_class(result@error, "error")
-      }
-    )
-  })
+    df_source <- local_data_frame_source(new_test_df())
 
-  it("handles NULL query gracefully", {
-    shiny::testServer(
-      app = function(input, output, session) {
-        df_source <- local_data_frame_source(new_test_df())
-        current_query <- shiny::reactiveVal("SELECT * FROM test_table")
-        current_title <- shiny::reactiveVal("All Data")
-
-        tool <- tool_update_dashboard_impl(
-          df_source,
-          current_query,
-          current_title
-        )
-
-        result <- tool(query = NULL, title = "Updated Title")
-      },
-      expr = {
-        expect_s7_class(result, ellmer::ContentToolResult)
-        expect_null(result@error)
-
-        # Query should not be updated when NULL
-        expect_equal(current_query(), "SELECT * FROM test_table")
-        expect_equal(current_title(), "Updated Title")
-      }
-    )
-  })
+    res_update <- NULL
+    impl_fn <- tool_update_dashboard_impl(df_source, function(query, title) {
+      res_update <<- list(query = query, title = title)
+    })
 
-  it("handles NULL title gracefully", {
-    shiny::testServer(
-      app = function(input, output, session) {
-        df_source <- local_data_frame_source(new_test_df())
-        current_query <- shiny::reactiveVal("SELECT * FROM test_table")
-        current_title <- shiny::reactiveVal("All Data")
-
-        impl_fn <- tool_update_dashboard_impl(
-          df_source,
-          current_query,
-          current_title
-        )
-
-        result <- impl_fn(
-          query = "SELECT * FROM test_table WHERE id = 1",
-          title = NULL
-        )
-      },
-      expr = {
-        # Title should not be updated when NULL
-        expect_equal(current_query(), "SELECT * FROM test_table WHERE id = 1")
-        expect_equal(current_title(), "All Data")
-      }
+    res_tool <- impl_fn(
+      query = "INVALID SQL",
+      title = "Should Not Update"
     )
+
+    # `update_fn` was not called
+    expect_null(res_update)
+    # because the tool resulted in an error
+    expect_s3_class(res_tool@error, class = "error")
   })
 })