---
title: "Chat with a model running on your own Ollama"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/13602aeb-5372-4bea-b249-02881178817c"
updated: "2026-11-12"
---

# Chat with a model running on your own Ollama

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow with a chat window. Each message goes through a Basic LLM Chain to a model served by Ollama on your own machine, and the answer comes back in the same window.

Chat with a model running on your own Ollama is an n8n workflow in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow puts a chat window in front of a model that runs on your own computer. You type a message in n8n’s chat, a Basic LLM Chain passes it to Ollama, and the model’s answer comes back to the same window. The file names no model, so the Ollama node asks for `llama3.2` unless you pick another. No cloud AI provider takes part. Three nodes do the work, beside two sticky notes that explain the flow and the Ollama address.

### Who it suits

Developers, tinkerers and privacy-minded teams who already run Ollama and want a quick chat front end inside n8n. Skip it if you need the model to remember the conversation or to use tools. As imported, each message is answered alone.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software | Developers | Try a new local model on real prompts before they build on it | A developer pulls a new model and sends the same five test questions to compare answers. |
| Consulting | Privacy-minded staff | Tidy and rewrite text on a machine where client notes never leave the office | A consultant cleans up meeting notes on the office server. |
| Education | Teachers and students | Practice prompt wording with no account and no fee | A class tries different phrasings on a laptop model during a lesson. |
| Home labs | Hobbyists | Chat from the browser with a model on a spare machine | A hobbyist asks the model on a home server to explain a log file. |

You need a little n8n and a working Ollama: import a file, add one credential and pick a model.

### Where to use it

Any n8n that can reach your Ollama will run it. The chat opens inside the n8n editor, so plan where people will use it.

- n8n on your own computer: the simplest case, with Ollama on the same machine
- An n8n server: point the credential at the machine that runs Ollama
- Docker: start the n8n container so it can reach the host’s network, as the workflow’s own note says
- A public chat page: turn on the Chat Trigger’s public option and add authentication first

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Install Ollama and pull a model first.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own, with a network path to Ollama |
| Ollama | Installed and running, with at least one model pulled |
| A model | The node asks for \`llama3.2\` unless you pick another |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Open `Ollama Chat Model` and create an Ollama credential. Its Base URL starts as `http://localhost:11434`. Change it if Ollama runs on another machine.
3. In the same node, pick one of your models in Model.
4. If n8n runs in Docker, start the container so it can reach the host’s network. The workflow’s note suggests the `--net=host` option.
5. Save, open the chat from the button at the bottom of the canvas and send a message.

### How to use it

Open the chat and send a message. The answer appears in the window when the model finishes. Each message is answered on its own, so paste in anything the model needs to know.

What to change for a different result

| To change | Where |
| --- | --- |
| The model | Model in \`Ollama Chat Model\` |
| Temperature, context length and keep alive | Add Option in the same node, which start at 0.7, 2,048 tokens and 5 minutes |
| A system message | Chat Messages in \`Chat LLM Chain\` |
| Who can chat | Make Chat Publicly Available in \`When chat message received\` |

### Example

A developer has pulled `llama3.2` on a laptop and wants to see how it handles a support email. They open the chat and paste the email, with the line `Reply in two friendly sentences` above it.

The chain sends that text to Ollama as one user message. The reply appears in the window as plain text. A second message reaches the model without the first, so the model cannot refer back to the email.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. Here a chat trigger feeds a chain, and the model node plugs into the chain from below. Send one message, then open the run to see what each node passed on.

**For experts.** The chain reads `chatInput` from the connected Chat Trigger and has no memory input.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`When chat message received\` | Chat Trigger 1.1 with no options set | Not public, and it answers when the last node finishes |
| \`Chat LLM Chain\` | Basic LLM Chain 1.4 with no parameters set | Sends \`chatInput\` as one user message, with no system message |
| \`Ollama Chat Model\` | Ollama chat model, version 1 | The file names no model, so the node asks for its default, \`llama3.2\` |

### Good to know

Everything stays on your own machine unless you point the credential somewhere else.

- Memory: none is connected, and a Basic LLM Chain has no memory input. For a conversation, swap in an AI Agent with a Simple Memory node
- Context: the node’s context length starts at 2,048 tokens. Raise it under Add Option if your messages are long
- Slow starts: Keep Alive starts at 5 minutes, after which Ollama can unload the model, so the first answer after a pause is slower
- Hardware: speed and quality depend on the model and your machine. There is no fee for each message
- Docker: a container cannot see your computer’s own \`localhost\` unless it shares the host’s network
- Not public: the chat opens only inside the n8n editor until you turn on Make Chat Publicly Available
- Your data: messages go only to the Ollama address in the credential
- Credentials: the JSON holds none

## README

```markdown
# Chat with a model running on your own Ollama

An n8n workflow with a chat window. You type a message, a Basic LLM Chain sends it to a model served by Ollama on your own
machine, and the answer comes back in the same window. No cloud AI provider is involved.

## What is inside

- `workflow.json`: the workflow as n8n exports it, five nodes, two of them sticky notes (one explains the flow, one the Ollama
  address). It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The Ollama Chat Model was linked to a credential in its author's n8n. The link is gone, so add your own.
- Nothing else. The file has no Code node and no expression.

## Before you start

- An n8n instance that can reach your Ollama over the network, on your own computer or a server.
- Ollama installed and running, with at least one model pulled. The file names no model, so the node uses its own default,
  `llama3.2`.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Open `Ollama Chat Model`. Under Credential to connect with, create an Ollama credential. Its Base URL starts as
   `http://localhost:11434`, the address Ollama listens on. Change it if Ollama runs on another machine.
3. If n8n runs in a Docker container, the container has to reach the host's network. The workflow's own note says to start it
   with the `--net=host` option.
4. In the same node, pick one of your models in Model. Without a choice the node asks Ollama for `llama3.2`.
5. Save, open the chat from the button at the bottom of the canvas and send a message.

## How a run goes

1. `When chat message received` (Chat Trigger 1.1) takes the message you type. Its Make Chat Publicly Available switch is off,
   so the chat opens only inside the n8n editor.
2. `Chat LLM Chain` (Basic LLM Chain 1.4) takes the prompt from the connected Chat Trigger, its `chatInput` field, and sends
   it as one user message. It has no system message and no memory.
3. `Ollama Chat Model` carries the request to the Ollama address in its credential. The model's answer returns as `text`, and
   the chat window shows it.

## Change the look

- The model: Model in `Ollama Chat Model`. Add Option there for temperature (0.7 as it stands), Context Length (2,048 tokens)
  and Keep Alive (5 minutes).
- A voice for the model: open `Chat LLM Chain` and add a System message under Chat Messages.
- Memory: a Basic LLM Chain has no memory input. To make it remember earlier messages, swap it for an AI Agent and connect a
  Simple Memory node.
- Who can chat: turn on Make Chat Publicly Available in the Chat Trigger, then add authentication before you share the
  address.

## Good to know

- Each message is answered on its own. Nothing connects the second message to the first.
- The node's context length starts at 2,048 tokens. Raise it under Add Option if your messages are long.
- The node's Keep Alive is 5 minutes: after that Ollama can unload the model, so the first answer after a pause is slower.
- Speed and quality come from your model and your hardware. There is no per-message fee.
- Your messages go only to the Ollama address in the credential. That stays on your machine unless you point it at a server.
```

## What is in it

3 files, 7 KB, downloaded as a zip.

```text
NOTICE.md  614 B
README.md  3 KB
workflow.json  3 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 2 steps, starting on a chat message
- AI: 1 step calls an AI model: Chat LLM Chain
- Sign-ins: Signs in to: Ollama
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 2 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/13602aeb-5372-4bea-b249-02881178817c)
- [Its page on Mindket](https://mindket.com/p/13602aeb-5372-4bea-b249-02881178817c)
