--- title: "DeepSeek chat and reasoning quick start with four examples" kind: "Kit" category: "Developer" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/dfc164d1-ff7c-43af-ab73-eed5c93aa2a2" updated: "2026-11-12" --- # DeepSeek chat and reasoning quick start with four examples > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n canvas with four ways to reach DeepSeek: a local R1 model on Ollama that answers the chat, two direct API calls with thinking on and off, and an agent with memory. DeepSeek chat and reasoning quick start with four examples 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 four ways to reach DeepSeek on one canvas. A chat message goes to a DeepSeek R1 model on your own Ollama server, and the reply comes back in the chat. Beside it sit two calls to DeepSeek’s own API, one with thinking on and one with it off, and a conversational agent with memory that reaches DeepSeek through an OpenAI credential. Only the local model is joined to the chat. The file holds fifteen nodes, seven of them sticky notes. ### Who it suits Developers who want a first working call to DeepSeek, local or hosted, and a place to copy the others from. Skip it if you want a finished chatbot. It is a set of starting points, and three of the four need joining up before they answer. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Software | Developers | Copy the API call that fits their own flow | A developer lifts the thinking-off call into a support-ticket workflow. | | IT services | Teams that keep text on site | Run R1 on their own server and compare it with the hosted API | A team asks the same contract question of the local model and of the hosted one. | | Education | AI course instructors | Show a class four routes to one model | An instructor runs each example live and points at what differs. | | Research | Analysts | Compare answers with thinking on and off | An analyst asks one maths question both ways and reads the two replies. | You need a little n8n and either an Ollama server or a DeepSeek API key: import a file, make the credentials you want and pick one example to run. ### Where to use it Any n8n that can reach Ollama or DeepSeek will run it. - n8n Cloud: the API examples, or the local one with an Ollama server that is reachable from the internet - Your own n8n server: all four, with Ollama on the same machine or the same Docker network - n8n’s chat: the canvas chat while you test. The public chat page stays off until you turn it on in the trigger ### How to set it up Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Make only the credentials for the examples you plan to run. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own | | Ollama | For the local example, a server with \`deepseek-r1:14b\` pulled, a 9.0 GB download | | DeepSeek | For the API examples, an API key from DeepSeek’s platform | | Credentials | Ollama, Header Auth for the two HTTP calls, and an OpenAI credential with DeepSeek’s Base URL for the agent | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. Local example: add an Ollama credential and select it in `Ollama DeepSeek`. 3. HTTP examples: add a Header Auth credential with the name `Authorization` and the value `Bearer ` followed by your key. Select it in `DeepSeek Raw Body` and `DeepSeek JSON Body`. 4. Agent: add an OpenAI credential with the Base URL `https://api.deepseek.com` and your DeepSeek key, and select it in `DeepSeek`. 5. Save, open the chat on the canvas and write a message. 6. To try an API example or the agent, draw a line from `When chat message received` to it, and remove the line to the Ollama chain. ### How to use it Write a message in the chat and the local DeepSeek model answers it. Join another example to the chat trigger to try that one instead. What to change for a different result | To change | Where | | --- | --- | | The local model | \`Ollama DeepSeek\`, with its context size and temperature | | The API model | The \`model\` line in each HTTP body, or \`DeepSeek\` | | Thinking on or off | The \`thinking\` line in the HTTP bodies | | The assistant’s instructions | The system message in \`Basic LLM Chain2\`, \`AI Agent\` or \`DeepSeek JSON Body\` | ### Example You type this in the chat. ```text Explain in two sentences why the sky is blue ``` The local model replies in the chat. If you joined `DeepSeek Raw Body` instead, the answer sits in `choices[0].message.content` of that node’s output, and the model’s reasoning sits beside it in `reasoning_content`. ### 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. This canvas holds four small flows. One is joined to the chat and three wait for you. Test the local one first, then join the next. Open each run under Executions to see what DeepSeek returned. **For experts.** The two API calls are plain HTTP Request nodes, so the same bodies work with any OpenAI-style endpoint. Where to look closer | Node | What it does | What to know | | --- | --- | --- | | \`Ollama DeepSeek\` | Ollama chat model \`deepseek-r1:14b\`, context 16384, temperature 0.6 | It feeds \`Basic LLM Chain2\` | | \`DeepSeek Raw Body\` | POST with a raw JSON body, \`deepseek-flash\`, thinking on | Your text goes in through \`JSON.stringify\` | | \`DeepSeek JSON Body\` | POST with the JSON body option, \`deepseek-flash\`, thinking off | A system message and your text | | \`DeepSeek\` | OpenAI chat model node, \`deepseek-flash\` | It needs an OpenAI credential with DeepSeek’s Base URL | | \`AI Agent\` | Conversational Agent type with \`Window Buffer Memory\` | Five exchanges of memory, and no tools | ### Good to know Three of the four examples are not joined to the chat, and DeepSeek has retired the model names the original used. - Model names: the original asked for \`deepseek-chat\` and \`deepseek-reasoner\`. DeepSeek’s change log, read on 12 November 2026, announced their end for 24 July 2026 and names \`deepseek-flash\` and \`deepseek-v4-pro\` as the current models. This copy uses \`deepseek-flash\` - Thinking: on by default at DeepSeek. A model in thinking mode ignores \`temperature\`, and its reasoning comes back as \`reasoning\_content\` beside \`content\` - Repairs: the JSON body had its system and user messages swapped, and both bodies broke on a quote in your text - Wiring: only the Ollama chain is joined. Join one example at a time - Billing: DeepSeek bills each API call, and the local model costs your own hardware - Your data: your messages go to DeepSeek in the API examples and stay on your Ollama server in the local one - Credentials: the JSON holds none ## README ```markdown # DeepSeek chat and reasoning quick start with four examples One canvas with four ways to reach DeepSeek from n8n. A local model on Ollama answers the chat. Beside it sit a call to DeepSeek's own API with thinking on, the same call with thinking off, and a conversational agent with memory. Only the local model is joined to the chat. The other three are there to copy from or to join up yourself. ## What is inside - `workflow.json`: the workflow as n8n exports it, fifteen nodes. Seven are sticky notes. It holds no credential. - `README.md`: these notes. ## What we changed from the original copy - The links to four credentials in its author's n8n are gone, so select your own. - The two API calls and the agent's model asked for `deepseek-chat` and `deepseek-reasoner`, which DeepSeek announced it would discontinue on 24 July 2026. All three now ask for `deepseek-flash`. The thinking-on call sends `"thinking": {"type": "enabled"}` and the thinking-off call sends `"thinking": {"type": "disabled"}`, which is how DeepSeek's change log says those two names behaved. - In `DeepSeek JSON Body` the system message held your chat text and the user message said "Hello!". They are the right way round now: the system message says "You are a helpful assistant." and the user message is your chat text. - Both HTTP bodies pasted your chat text between quotation marks, so a quote or a line break in it broke the JSON. They now use `JSON.stringify` on it. - The sticky notes were reworded to say which example is joined to the chat, and the long one about the API now lists the current model names. - The wiring is as the original copy had it: only the Ollama chain is joined to the chat trigger. ## Before you start - An n8n instance, on n8n Cloud or your own server. - For the local example: an Ollama server that n8n can reach, with the model pulled: `ollama pull deepseek-r1:14b`. It is a 9.0 GB download, and `Ollama DeepSeek` asks for a context of 16,384 tokens. - For the other three: a DeepSeek API key from `https://platform.deepseek.com/api_keys`. ## Set it up 1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`. 2. The local example: add an Ollama credential (Base URL `http://localhost:11434` unless you changed `OLLAMA_HOST`) and select it in `Ollama DeepSeek`. Save, open the chat on the canvas and write a message. 3. The two HTTP examples: add a Header Auth credential. Its name is `Authorization` and its value is `Bearer ` followed by your key. Select it in `DeepSeek Raw Body` and `DeepSeek JSON Body`. 4. The agent: add an OpenAI credential whose Base URL is `https://api.deepseek.com` and whose key is your DeepSeek key. Select it in `DeepSeek`. 5. To try one of those three, draw a line from `When chat message received` to its first node. Remove the line to the Ollama chain first, so that only one example answers. ## How a request runs 1. `When chat message received` passes your message to `Basic LLM Chain2` as `chatInput`. 2. The chain sends it to `Ollama DeepSeek`, which runs `deepseek-r1:14b` with a temperature of 0.6. The system message is "You are a helpful assistant." 3. The reply goes back to the chat. The three unjoined examples work the same way once you join them. `DeepSeek Raw Body` and `DeepSeek JSON Body` post to `https://api.deepseek.com/chat/completions`. The agent keeps the last five exchanges in `Window Buffer Memory`. ## Change the result - The local model: `Ollama DeepSeek`, with any model you have pulled. Its options hold the context size and the temperature. - The API model: the `model` line in each HTTP body, or the model in `DeepSeek`. `deepseek-v4-pro` is DeepSeek's other current model. - Thinking: `"type": "enabled"` or `"disabled"` in the HTTP bodies. Thinking is on by default at DeepSeek, and a model in thinking mode ignores `temperature`. - The assistant's instructions: the system message in `Basic LLM Chain2`, `AI Agent` or `DeepSeek JSON Body`. ## Good to know - Model names: DeepSeek's change log, read on 12 November 2026, names `deepseek-flash` and `deepseek-v4-pro` as the current models. It lists `deepseek-chat` and `deepseek-reasoner` as due for discontinuation on 24 July 2026, so a copy that still asks for them may already fail. - The agent uses the Conversational Agent type of n8n's older Agent node, version 1.7. It has no tools. - `deepseek-r1` is a reasoning model, so a reply can begin with its chain of thought. - With thinking on, the reasoning comes back in a field named `reasoning_content` beside `content`. Read the answer from `choices[0].message.content`. - Billing: DeepSeek bills each API call, and the local model costs your own hardware. - Your messages go to DeepSeek in the API examples and stay with your Ollama server in the local one. - The chat trigger's public page is off until you turn it on in the trigger. Leave it off unless you want strangers using your keys. ``` ## What is in it 3 files, 14 KB, downloaded as a zip. ```text NOTICE.md 636 B README.md 5 KB workflow.json 8 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 - Not reached: 5 nodes no run reaches: AI Agent, DeepSeek, Window Buffer Memory, DeepSeek Raw Body and DeepSeek JSON Body - AI: 1 step calls an AI model: Basic LLM Chain2 - 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/dfc164d1-ff7c-43af-ab73-eed5c93aa2a2) - [Its page on Mindket](https://mindket.com/p/dfc164d1-ff7c-43af-ab73-eed5c93aa2a2)