@@ -5,6 +5,7 @@ on:
     branches: [master]
   pull_request:
     paths:
+      - motoko/llm_chatbot/**
       - rust/llm_chatbot/**
       - .github/workflows/llm_chatbot.yml
 
@@ -13,6 +14,19 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  motoko-llm_chatbot:
+    runs-on: ubuntu-24.04
+    container: ghcr.io/dfinity/icp-dev-env-motoko:1.0.1
+    env:
+      ICP_CLI_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+      - name: Deploy
+        working-directory: motoko/llm_chatbot
+        run: |
+          icp network start -d
+          icp deploy
+
   rust-llm_chatbot:
     runs-on: ubuntu-24.04
     container: ghcr.io/dfinity/icp-dev-env-rust:1.0.1
 
@@ -1,46 +1,79 @@
 # LLM Chatbot
 
-The LLM Chatbot example demonstrates how an ICP smart contract can be used to interact with a large language model (LLM) to generate text. The user can input a prompt, and the smart contract will use the LLM to generate a response.
-The response is then returned to the user, and the user can submit some follow-up prompts to continue the conversation.
+This example demonstrates how an ICP canister can interact with a large language model (LLM) to generate text. The user can input a prompt and the canister will use the LLM to generate a response. Follow-up prompts continue the conversation with the full message history.
 
-## Deploying from ICP Ninja
+## How it works
 
-When viewing this project in ICP Ninja, you can deploy it directly to the mainnet for free by clicking "Run" in the upper right corner. Open this project in ICP Ninja:
+The backend canister calls the [LLM canister](https://forum.dfinity.org/t/introducing-the-llm-canister-deploy-ai-agents-with-a-few-lines-of-code/41424)'s `v1_chat` endpoint directly (see `backend/app.mo`), without a helper library. It reads the LLM canister's principal from the `PUBLIC_CANISTER_ID:llm` environment variable. Locally, `icp deploy` deploys a copy of the LLM canister (backed by Ollama) and injects this variable automatically. On mainnet the shared LLM canister already exists, so `icp.yaml` sets the variable to its principal (`w36hm-eqaaa-aaaal-qr76a-cai`) for the `ic` environment.
 
-[![](https://icp.ninja/assets/open.svg)](https://icp.ninja/i?g=https://github.com/dfinity/examples/motoko/llm_chatbot)
+## Build and deploy from the command line
 
-## Build and deploy from the command-line
+### Prerequisites
 
-### 1. [Download and install the IC SDK.](https://internetcomputer.org/docs/building-apps/getting-started/install)
+- Node.js
+- icp-cli: `npm install -g @icp-sdk/icp-cli @icp-sdk/ic-wasm`
+- ic-mops: `npm install -g ic-mops`
 
-### 2. Setting up Ollama
+### Set up Ollama (local deployment only)
 
-To be able to test the agent locally, you'll need a server for processing the agent's prompts. For that, we'll use `ollama`, which is a tool that can download and serve LLMs.
-See the documentation on the [Ollama website](https://ollama.com/) to install it. Once it's installed, run:
+The LLM canister delegates inference to [Ollama](https://ollama.com/). Install it and then run:
 
-```
+```bash
 ollama serve
-# Expected to start listening on port 11434
 ```
 
-The above command will start the Ollama server, so that it can process requests by the agent. Additionally, and in a separate window, run the following command to download the LLM that will be used by the agent:
+In a separate terminal, download the model (about 4 GiB, one-time) and load it
+into memory:
+
+```bash
+ollama run llama3.1:8b "hi"
+```
+
+`ollama run` pulls the model if needed and warms it in memory. This matters: the
+LLM canister's HTTP outcall to Ollama has a ~30 s deadline, and a cold model
+load alone can take longer than that — so the *first* call after `ollama serve`
+starts may time out (`SysFatal: Timeout expired`) if the model isn't warm yet.
+Warming it first avoids this; `ollama serve` then keeps it loaded. If you do hit
+a timeout on the first call, simply retry — the model stays resident afterwards.
+
+### Install
 
+```bash
+git clone https://github.com/dfinity/examples
+cd examples/motoko/llm_chatbot
 ```
-ollama run llama3.1:8b
+
+### Deploy
+
+```bash
+icp network start -d
+icp deploy
 ```
 
-The above command will download an 8B parameter model, which is around 4GiB. Once the command executes and the model is loaded, you can terminate it. You won't need to do this step again.
+Open the frontend URL printed by `icp deploy` to use the chatbot in the browser. Make sure Ollama is running with the model warmed (see above) so the first message does not time out.
 
-### 3. Download your project from ICP Ninja using the 'Download files' button on the upper left corner, or [clone the GitHub examples repository.](https://github.com/dfinity/examples/)
+For hot-reload frontend development:
 
-### 4. Navigate into the project's directory.
+```bash
+npm run dev --prefix frontend
+```
 
-### 5. Deploy the project to your local environment:
+## Deploying to mainnet
 
+```bash
+icp deploy -e ic
 ```
-dfx start --background --clean && dfx deploy
+
+No Ollama setup is needed — mainnet calls go directly to the LLM canister at `w36hm-eqaaa-aaaal-qr76a-cai`.
+
+## Updating the Candid interface
+
+The `backend/backend.did` file defines the backend canister's public interface. The frontend TypeScript bindings are auto-generated from this file during the frontend build. If you modify the backend's public API, regenerate the `.did` file:
+
+```bash
+mops generate candid backend
 ```
 
 ## Security considerations and best practices
 
-If you base your application on this example, it is recommended that you familiarize yourself with and adhere to the [security best practices](https://internetcomputer.org/docs/building-apps/security/overview) for developing on ICP. This example may not implement all the best practices.
+If you base your application on this example, familiarize yourself with the [security best practices](https://docs.internetcomputer.org/guides/security/overview) for developing on ICP. This example may not implement all best practices.
@@ -1,14 +1,85 @@
-import LLM "mo:llm";
+import Runtime "mo:core/Runtime";
 
-persistent actor {
-  public func prompt(prompt : Text) : async Text {
-    await LLM.prompt(#Llama3_1_8B, prompt);
+// The backend calls the LLM canister's `v1_chat` endpoint directly. The request
+// and response types below mirror that canister's Candid interface:
+// https://dashboard.internetcomputer.org/canister/w36hm-eqaaa-aaaal-qr76a-cai#interface
+//
+// LLM canister interface:
+//   v1_chat : (chat_request_v1) -> (chat_response_v1)
+//
+// This example does not use tools, so the optional `tools` field is omitted from
+// the request — Candid decodes an absent optional record field as `null` on the
+// canister side, keeping the call wire-compatible.
+actor {
+
+  // A message in a chat. Mirrors `chat_message_v1` in the LLM canister interface.
+  public type ChatMessage = {
+    #user : { content : Text };
+    #system_ : { content : Text };
+    #assistant : AssistantMessage;
+    #tool : { content : Text; tool_call_id : Text };
+  };
+
+  // The assistant's reply. Mirrors `assistant_message`.
+  public type AssistantMessage = {
+    content : ?Text;
+    tool_calls : [ToolCall];
+  };
+
+  public type ToolCall = {
+    id : Text;
+    function : FunctionCall;
+  };
+
+  public type FunctionCall = {
+    name : Text;
+    arguments : [ToolCallArgument];
+  };
+
+  public type ToolCallArgument = {
+    name : Text;
+    value : Text;
+  };
+
+  // Request/response for `v1_chat`. The request omits the optional `tools` field
+  // (see the note above).
+  type Request = {
+    model : Text;
+    messages : [ChatMessage];
+  };
+  type Response = { message : AssistantMessage };
+  type LlmActor = actor { v1_chat : (Request) -> async Response };
+
+  // The model this example uses. The LLM canister identifies models by string;
+  // other available models include "qwen3:32b" and "llama4-scout".
+  let model = "llama3.1:8b";
+
+  // The LLM canister ID is injected as PUBLIC_CANISTER_ID:llm at deploy time:
+  //   local: auto-injected by icp-cli after deploying the pre-built llm canister
+  //   ic:    set explicitly in icp.yaml to the shared mainnet LLM canister
+  //
+  // See icp.yaml for the environment configuration.
+  func llmCanister<system>() : LlmActor {
+    let ?id = Runtime.envVar<system>("PUBLIC_CANISTER_ID:llm") else Runtime.trap("PUBLIC_CANISTER_ID:llm not set — run icp deploy");
+    actor (id) : LlmActor;
+  };
+
+  func sendChat<system>(messages : [ChatMessage]) : async AssistantMessage {
+    let response = await llmCanister<system>().v1_chat({ model; messages });
+    response.message;
   };
 
-  public func chat(messages : [LLM.ChatMessage]) : async Text {
-    let response = await LLM.chat(#Llama3_1_8B).withMessages(messages).send();
+  public func prompt(prompt : Text) : async Text {
+    let message = await sendChat<system>([#user({ content = prompt })]);
+    switch (message.content) {
+      case (?text) text;
+      case null "";
+    };
+  };
 
-    switch (response.message.content) {
+  public func chat(messages : [ChatMessage]) : async Text {
+    let message = await sendChat<system>(messages);
+    switch (message.content) {
       case (?text) text;
       case null "";
     };
 
@@ -0,0 +1,34 @@
+type ToolCallArgument = 
+ record {
+   name: text;
+   value: text;
+ };
+type ToolCall = 
+ record {
+   function: FunctionCall;
+   id: text;
+ };
+type FunctionCall = 
+ record {
+   arguments: vec ToolCallArgument;
+   name: text;
+ };
+type ChatMessage = 
+ variant {
+   assistant: AssistantMessage;
+   system: record {content: text;};
+   tool: record {
+           content: text;
+           tool_call_id: text;
+         };
+   user: record {content: text;};
+ };
+type AssistantMessage = 
+ record {
+   content: opt text;
+   tool_calls: vec ToolCall;
+ };
+service : {
+  chat: (messages: vec ChatMessage) -> (text);
+  prompt: (prompt: text) -> (text);
+}