Ollama integrations and ecosystem

Parent: Ollama · Published reference · snapshot 2026-10-14 · skill ollama-expert/references/ollama-integrations-ecosystem.md

↓ Facts as markdown all context files

Ollama integrations are the tools and libraries that connect to a local or cloud Ollama server. The ollama launch command sets up and runs coding tools such as Claude Code, OpenCode and Codex with local or cloud models; the Go api package, ollama-python and ollama-js read OLLAMA_HOST; langchain-ollama provides ChatOllama; editors (Cline, Roo Code, Zed, JetBrains, VS Code), MCP bridges (ollmcp, MCPHost), agent harnesses (OpenClaw, Hermes Agent, Pi) and n8n nodes connect through the native or OpenAI-compatible endpoints. Sources: docs.ollama.com plus vendor docs, READMEs and community posts.

These notes link each claim to its source. Some citations identify archived research reports that are no longer hosted on this site. A published reference means the content is available; it does not certify independent review or accuracy.Read the editorial policy and follow the sources before relying on a claim.

Definitions

ollama launch is a new command which sets up and runs your favorite coding tools like Claude Code, OpenCode, and Codex with local or cloud models. No environment variables or config files needed. [source]
The Go client is the `api` package inside the main `github.com/ollama/ollama` module, not a separate module. `api.ClientFromEnvironment()` reads OLLAMA_HOST; `Generate` and `Chat` stream to a callback. The ollama CLI itself uses this package. [source]
LangChain's Python Ollama chat integration is the langchain-ollama package; ChatOllama supports bind_tools tool calling, image input, token streaming, native async and logprobs, and the docs example uses validate_model_on_init=True. [source]
On macOS and Windows, the Hermes Desktop installer is the recommended upstream installation path. It installs the desktop app and Hermes Agent together. If you prefer the command line, `ollama launch hermes-desktop` remains the explicit Ollama-managed path and uses the same Hermes configuration, sessions, skills, and memory as the CLI. [source]
<Note>If Cline CLI is not installed and `npm` is available, `ollama launch cline` will prompt to install `cline@latest`.</Note> [source]
Refer to [LangChains's Ollama Chat Model documentation](https://js.langchain.com/docs/integrations/chat/ollama/) for more information about the service. [source]
OpenCode is an open-source coding agent that runs in your terminal, reads your project, edits files, and runs commands. Ollama configures OpenCode to use local and cloud models. [source]
Hermes Desktop is a native AI assistant app by Nous Research. It provides a desktop chat interface for Hermes Agent, an AI agent that can work with models, run tools, manage projects, use memory and skills, and connect to messaging gateways. [source]
Self-hosted AI Package is an open, docker compose template that quickly bootstraps a fully featured Local AI and Low Code development environment including Ollama for your local LLMs, Open WebUI for an interface to chat with your N8N agents, and Supabase for your database, vector store, and authentication. [source]
MCP Client for Ollama (ollmcp) is a modern, interactive terminal application (TUI) built for harness engineering, connecting local Ollama LLMs to one or more Model Context Protocol (MCP) servers. By fully supporting the core MCP primitives (tools, prompts, and resources), it provides a controlled terminal space where you steer, and the agent executes. With a rich, user-friendly interface, it lets you safely manage your setup in real time with no coding required. Whether you're building, testing, or exploring, this client streamlines your workflow with features like fuzzy autocomplete, advanced [source]
OpenClaw is a personal AI assistant that runs on your own devices. It bridges messaging services (WhatsApp, Telegram, Slack, Discord, iMessage, and more) to AI coding agents through a centralized gateway. [source]
Refer to Ollama's [How can I allow additional web origins to access Ollama?](https://docs.ollama.com/faq#how-can-i-allow-additional-web-origins-to-access-ollama) for more information. [source]
ChatGPT and Claude models are not recommended for no reason. They just work [source]
Hermes Agent is a self-improving AI agent built by Nous Research. It features automatic skill creation, cross-session memory, and 70+ skills that it ships with by default. [source]
Cline CLI is an autonomous coding agent for interactive terminal sessions. [source]
Oh My Pi (OMP) is a terminal coding agent with IDE-style tools built in. It combines chat, project context, structured code edits, language server support, debugging tools, browser access, plugins, and subagents in one terminal workflow. [source]
Widespread misconfiguration of popular AI assistant OpenClaw means many instances are exposed to the public-facing internet, SecurityScorecard has warned. [source]
Note: The files parameter is not currently supported in ollama-js. [source]
Roomote is not yet publicly available. Here's what former Roo Code users are choosing right now. [source]
The report concludes that OpenClaw is not an isolated case but a leading indicator of a broader security challenge facing agentic AI. [source]
MCPHost is a CLI tool that allows you to interact with various AI models through a unified interface. It supports various tools through MCP servers and can run in both interactive and non-interactive modes. [source]
Claude Code + local models are not practical at this time. [source]

Structure and components

In n8n, you first create an Ollama credential, which consists of two fields: the base URL of your Ollama instance and an optional API key for bearer token authentication for remote or proxy-secured installations. The default base URL is http://localhost:11434. If you have set the environment variable OLLAMA_HOST on your Ollama server, enter exactly that value instead, as described by the official n8n documentation on Ollama credentials. If you encounter connection errors with the IPv6 message "ECONNREFUSED ::1:11434", it often helps to replace localhost with the IPv4 address 127.0.0.1. [source]
Part 2 — Calling Ollama via the official Go SDK (github.com/ollama/ollama/api) [source]
const ollama = new Ollama() const response = await ollama.chat({ model: 'gpt-oss:120b-cloud', messages: [{ role: 'user', content: 'Explain quantum computing' }], stream: true, }) for await (const part of response) { process.stdout.write(part.message.content) } [source]
Ollama MCP Bridge - A Python API layer that sits in front of Ollama, automatically adding tools from multiple MCP servers to every chat request. This project provides a transparent proxy solution that pre-loads all MCP servers at startup and seamlessly integrates their tools into the Ollama API. [source]
async def chat(): message = {'role': 'user', 'content': 'Why is the sky blue?'} async for part in await AsyncClient().chat(model='gemma4', messages=[message], stream=True): print(part['message']['content'], end='', flush=True) [source]
Servers added via ollmcp mcp add are always loaded as the base layer. Any flags (--mcp-server, --mcp-server-url, --servers-json, --claude-desktop) add on top. To include servers from Claude Desktop, pass --claude-desktop explicitly. [source]
As far as needing a bigger model for calling tools? That’s one of the models that been 100% reliable in calling tools with-in n8n, so I do not think the size of the model is playing a part in the issue. [source]

How it works

Cline: set API Provider to Ollama, base URL http://localhost:11434, pick a model. Ollama's page says use a context window of at least 32K for coding; Cline's own docs name no number but advise enabling Use Compact Prompt (Settings, Features), keeping tasks focused and starting a new task when context grows. [source]
OpenClaw talks to Ollama's native API (/api/chat), not the OpenAI-compatible /v1 endpoint. Its docs say not to use the /v1 URL because it breaks tool calling and models may print raw tool-call JSON as text. Set `baseUrl` to `http://host:11434` (no /v1); `baseUrl` is the canonical key, `baseURL` is accepted. [source]
In LlamaIndex's Ollama LLM, structured_predict sets the response format to the Pydantic class's JSON schema (overriding json_mode); tool calls are limited to one per response unless allow_parallel_tool_calls is set; tool IDs equal the tool name because Ollama supplies none; additional_kwargs merge after defaults and override temperature/num_ctx. [source]
The Ollama Chat Model node connects to a locally hosted Ollama instance using the base URL defined by [Ollama credentials](/integrations/builtin/credentials/ollama.md). When you run either n8n or Ollama in Docker, you need to configure the network so that n8n can connect to Ollama. [source]
When launched through ollama launch codex, Ollama refreshes the model catalog and uses a dedicated Codex profile for that session. Type /model inside Codex to switch between your installed, tool-capable Ollama models without restarting. The starting model remains selected, and each model keeps its own context window, vision, and thinking settings. Pull additional models with ollama pull <model> before launching to include them in the picker. To configure without launching: [source]
When launched through `ollama launch cline`, Ollama sets Cline's provider to Ollama, points it at the local Ollama endpoint, and selects the model you choose. [source]
When launched through `ollama launch codex`, Ollama refreshes the model catalog and uses a dedicated Codex profile for that session. [source]
The Ollama Chat Model node is a sub-node[^1]. Sub-nodes behave differently than other nodes when processing multiple items using expressions. [source]
If you are running n8n in Docker on **Linux**, use the `--add-host` flag to map `host.docker.internal` to `host-gateway` when you start the container. For example: [source]
const ollama = new Ollama({ host: 'https://ollama.com', headers: { Authorization: 'Bearer ' + process.env.OLLAMA_API_KEY }, }) [source]
Roo Code automatically defers to the Modelfile's num_ctx setting by default. When you use a model with Ollama, Roo Code reads the model's configured context window and uses it automatically. You don't need to configure context size in Roo Code settings - it respects what's defined in your Ollama model. [source]
Cause If no model instance is running, Ollama spins one up on demand. During that cold start it may allocate a larger context window than expected. The larger context window increases memory usage and can exceed available VRAM or RAM. This is an Ollama startup behavior, not a Roo Code bug. [source]
The Ollama context window defaults to 4096 tokens across standard models, silently truncating conversation history when inputs exceed runtime memory limits. While tuning the num_ctx parameter allows moderate expansion, inflating the context window on local GPUs rapidly triggers out-of-memory crashes. Connecting your assistant to an intelligent workspace via the Model Context Protocol allows semantic search across large document corpuses without exhausting local video memory. [source]
* Only requests made with an Ollama model go to Ollama. ChatGPT's native models keep using their usual provider. * Ollama models are for Codex mode. Regular Chat and voice keep using their usual ChatGPT connection. * Codex manages sessions. Ollama routes model requests and compaction when Codex asks for it, but does not store ChatGPT sessions. * Web search uses Ollama's web-search service when you use an Ollama model. It requires Ollama sign-in and is limited to three calls per response. [source]
The configuration also records a defaultProvider. When you run ollmcp with no --provider flag, it loads that provider's profile; a fresh install starts on ollama. Each time you /save-config, the provider you're currently using becomes the new default, so running plain ollmcp resumes wherever you left off. Pass --provider <name> at any time to switch to (and load) a different provider's profile, and --model / --host / --api-key override the saved values for that run. [source]
When creating a new workflow, select Add a first step and select an Ollama node [source]
Open Ollama **Settings**, select **Apps**, then select ChatGPT. Choose up to five compatible local or cloud models and save your changes. Ollama asks to restart ChatGPT when a model change needs one. [source]
4. When creating a new workflow, select **Add a first step** and select an **Ollama node** [source]
Open WebUI is designed to be **Protocol-Oriented**. This means that when we refer to "Ollama", we are specifically referring to the **Ollama API Protocol** (typically running on port `11434`). [source]
> **A system prompt set here is a fallback** > > Ollama uses the model's own system prompt only when a chat sends none. A system prompt from the model's settings in **Workspace** > **Models**, from a user's settings, or added by a filter replaces it. To give a model a system prompt that always applies in Open WebUI, set it in **Workspace** > **Models** instead. [source]
If you're connecting to Ollama through authenticated proxy services (such as [Open WebUI](https://docs.openwebui.com/getting-started/api-endpoints/#-ollama-api-proxy-support)) you must include an API key. If you don't need authentication, leave this field empty. When provided, the API key is sent as a Bearer token in the `Authorization` header of the request to the Ollama API. [source]
Added to the mix is that because OpenClaw agents are designed to act with legitimate authority, malicious activity can appear normal and, as a consequence, delay detection and increase potential impact. [source]
Breaking change: --auto-discovery / -a has been replaced by --claude-desktop. Additionally, servers added via ollmcp mcp add are now always loaded automatically, they are no longer a fallback that disappears when other flags are used. Claude Desktop servers are never loaded automatically; use --claude-desktop to include them. [source]
Prompts are discovered automatically when you connect to MCP servers. If a server supports prompts, they'll be available immediately in the prompts list and autocomplete. [source]
Resources are discovered automatically when you connect to MCP servers. If a server supports resources, they'll be available immediately in the resources list and @ autocomplete. [source]
This feature dramatically improves the development experience when building and testing MCP servers. [source]
When using GitHub MCP server, make sure to replace "mytoken" with your actual GitHub API token. [source]
The model deepseek-v3.1:671b-cloud only supports tool use when thinking mode is turned off. You can toggle thinking mode in ollmcp by typing either /thinking-mode or /tm. [source]
The --yes flag skips selectors, pulls the model when needed, and requires --model. Arguments after -- are passed directly to Claude Code. [source]
When executed, "Launching Claude Code with {model}..." is displayed, and Claude Code launches with environment variables automatically configured. If no model is specified, one is automatically selected from available models. [source]
Problems Occur When Connecting with Claude Code [source]
However, various problems occurred when connecting with Claude Code. [source]
In response to the instruction "write code," it returned a calculation result. When I explicitly instructed "write FizzBuzz code in TypeScript," it succeeded, but that's different from how Claude Code is naturally used. [source]
<div> <div>Command line</div> <div>Run commands with Claude Code's permission flow</div> </div> </div> [source]
The `--yes` flag skips selectors, pulls the model when needed, and requires `--model`. Arguments after `--` are passed directly to Claude Code. [source]

How-to and procedures

Continue configures Ollama in a YAML config (~/.continue/configs/config.yaml) via model blocks (uses: ollama/<model>), model: AUTODETECT, or manual provider: ollama with apiBase and roles. It does not auto-pull: a missing tag returns 404 until you run ollama pull with the exact tag. [source]
Goose has a built-in Ollama provider. For models without native tool calling, an experimental tool shim (enabled with `GOOSE_TOOLSHIM=true goose session`) uses an interpreter model, default `mistral-nemo` (`ollama pull mistral-nemo`), to turn the primary model's output into tool calls. The docs say behavior and configuration may change. [source]
Run `ollama launch` in a terminal and choose OpenClaw or Hermes Agent. [source]
Run `ollama launch hermes-desktop` again to switch models later. [source]
Run all your local AI together in one package - Ollama, Supabase, n8n, Open WebUI, and more! [source]
Run n8n in docker with `--add-host=host.docker.internal:host-gateway` [source]
Run `ollama launch` in a terminal to choose a coding agent. [source]
Install Claude Code, then set your [API key](/quickstart#build-an-application) in `OLLAMA_API_KEY`. No Ollama installation required. [source]
Ensure the model's context window is pinned Save your Ollama model with an appropriate num_ctx (via /set + /save, or preferably a Modelfile). Roo Code automatically detects and uses the model's configured num_ctx - there is no manual context size setting in Roo Code for the Ollama provider. [source]
Configure Ollama to listen on all interfaces by binding to `0.0.0.0` inside of the container (the official images are already configured this way). [source]
Use ANTHROPIC_AUTH_TOKEN for bearer authentication. Claude settings can override shell variables. Update any base URL or credentials in those settings, then run /status to check the connection. Choose a cloud model that supports tools. Basic chat and file edits work with compatible models. Hosted WebSearch and advanced tool controls are not fully supported. See Anthropic compatibility. [source]
Use `ANTHROPIC_AUTH_TOKEN` for bearer authentication. Claude settings can override shell variables. Update any base URL or credentials in those settings, then run `/status` to check the connection. [source]
Install the Codex CLI. For the ChatGPT desktop app, see ChatGPT Desktop. [source]
Use a context window of at least 64k tokens for Codex. [source]
Install langchain-ollama and download any models you want to use from ollama. [source]
Use the same model tag in `ollama pull` and `ChatOllama(model=...)`. The image, log probability, and custom-role examples below include separate pull commands for their models. [source]
Install the [Codex CLI](https://developers.openai.com/codex/cli/). For the ChatGPT desktop app, see [ChatGPT Desktop](/integrations/chatgpt). [source]
Run Cline with local models using Ollama, LM Studio or Atomic Chat. [source]
Use Ollama’s web search API from Claude Code. See Web search for setup and usage. [source]
Run Ollama on your Mac for faster inference, and connect to that from the n8n instance: [source]
Use Ollama's web search API from Claude Code. [source]
To use `codex` with Ollama, use the `--oss` flag: [source]
Add an Ollama provider to `opencode.json`: [source]
Run `droid` in a new terminal to load the new settings. [source]
To use Ollama, you will need a JetBrains AI Subscription. [source]
To access Granite 3.2's thinking features, pass a message with a `"control"` role with content set to `"thinking"`. Because `"control"` is a non-standard message role, use a [ChatMessage](https://reference.langchain.com/python/langchain-core/messages/chat/ChatMessage) object to implement it: [source]
Avoid pip install --break-system-packages ollmcp. It works, but it installs into the system Python and can break packages your OS depends on. [source]
To enable, run ollmcp --install-completion and follow the instructions for your shell [source]
Run Cline with local inference on your machine. [source]
Enable Use Compact Prompt in Cline Settings → Features [source]
Run commands with Claude Code’s permission flow [source]
Use `/loop` inside Claude Code to run a prompt or slash command on a schedule: [source]
Install the [Cline CLI](https://docs.cline.bot/usage/cli-overview). For the IDE extension, see [Cline](/integrations/cline). [source]

Examples and snippets

```toml theme={"system"} — `model = "gpt-oss:120b"` … [source]
```shell theme={"system"} — `codex --profile ollama-launch -c 'web_search="disabled"'` … [source]
```bash theme={"system"} — `ollama launch hermes-desktop -- --force-build` … [source]
```shell theme={"system"} — `ollama launch pi --model qwen3.5:cloud` … [source]
``` — `codex --profile ollama-launch` … [source]
```shell theme={"system"} — `ANTHROPIC_BASE_URL=https://ollama.com \` … [source]
```shell theme={"system"} — `ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY="" claude --model kimi` … [source]
```bash theme={"system"} — `ollama launch openclaw` … [source]
```bash theme={"system"} — `ollama launch openclaw --config` … [source]
```bash theme={"system"} — `ollama launch openclaw --model kimi-k2.5:cloud` … [source]
```bash theme={"system"} — `ollama launch openclaw --model kimi-k2.5:cloud --yes` … [source]
```bash theme={"system"} — `ollama launch pi` … [source]
```shell theme={"system"} — `ollama launch pi --config` … [source]
``` — `ollama launch claude` … [source]
``` — `ollama launch claude --model qwen3.5` … [source]
```shell theme={"system"} — `ollama launch claude` … [source]
```shell theme={"system"} — `ollama launch claude --model gemma4:cloud --yes -- -p "how does this repository work?"` … [source]
```shell theme={"system"} — `ollama launch claude -- --channels plugin:telegram@claude-plugins-official` … [source]
```bash theme={"system"} — `ollama launch cline` … [source]
```shell theme={"system"} — `ollama launch cline --config` … [source]
```shell theme={"system"} — `ollama launch cline --model qwen3.5` … [source]
```shell theme={"system"} — `ollama launch cline --model kimi-k2.6:cloud` … [source]
```shell theme={"system"} — `ollama launch cline -- "summarize this repository"` … [source]
```shell theme={"system"} — `ollama launch cline -- kanban` … [source]
``` — `ollama launch codex` … [source]
```shell theme={"system"} — `ollama launch copilot` … [source]
```shell theme={"system"} — `ollama launch copilot --model kimi-k2.5:cloud --yes -- -p "how does this repository work?"` … [source]
```bash theme={"system"} — `ollama launch hermes-desktop` … [source]
```bash theme={"system"} — `ollama launch hermes-desktop --model <model>` … [source]
```json theme={"system"} — `"$schema": "https://opencode.ai/config.json",` … [source]
```json theme={"system"} — `"custom_models": [` … [source]
``` — `ollama launch droid --config` … [source]
```bash theme={"system"} — `ollama launch droid` … [source]
```shell theme={"system"} — `ollama launch droid --config` … [source]
```shell — `docker run -it --rm --add-host host.docker.internal:host-gateway --name n8n -p 5678:5678 -v n8n_data:/home/nod` … [source]
```bash theme={"system"} — `pi install npm:@ollama/pi-web-search` … [source]
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}} — `from typing import List` … [source]
```typescript — `import { Ollama } from 'ollama';` … [source]
```shell theme={"system"} — `export ANTHROPIC_AUTH_TOKEN=ollama # required but ignored` … [source]
```shell theme={"system"} — `cline auth` … [source]
```shell theme={"system"} — `cline config` … [source]
```shell theme={"system"} — `cline` … [source]
``` — `codex --oss -m gpt-oss:120b` … [source]
``` — `codex --oss -m gpt-oss:120b-cloud` … [source]
```typescript — `import { generateText } from 'ai';` … [source]
```python theme={"system"} — `import os` … [source]
```shell theme={"system"} — `ollama launch dsh` … [source]
```shell theme={"system"} — `ollama launch dsh --model qwen3.8` … [source]
```shell theme={"system"} — `ollama launch dsh --config` … [source]
```shell theme={"system"} — `ollama launch dsh -- --port 3081` … [source]
```json theme={"system"} — `"custom_models": [` … [source]
```bash theme={"system"} — `ollama launch omp` … [source]
```shell theme={"system"} — `ollama launch omp --model <model>` … [source]
```bash theme={"system"} — `ollama launch omp --config` … [source]
```shell theme={"system"} — `ollama launch pool` … [source]
```shell theme={"system"} — `ollama launch pool -- --help` … [source]
```shell theme={"system"} — `export POOLSIDE_STANDALONE_BASE_URL=http://localhost:11434/v1` … [source]
```shell theme={"system"} — `POOLSIDE_STANDALONE_BASE_URL=http://localhost:11434/v1 POOLSIDE_API_KEY=ollama pool -m kimi-k2.6:cloud` … [source]
```python — `from llama_index.llms.ollama import Ollama` … [source]
```bash theme={"system"} — `hermes gateway setup` … [source]
``` — `Connect a messaging platform? (Telegram, Discord, etc.)` … [source]
```typescript — `import { ollama } from 'ai-sdk-ollama';` … [source]
```bash theme={"system"} — `curl -fsSL https://www.nvidia.com/nemoclaw.sh | \` … [source]
```typescript — `import { ollama, generateText, streamText } from 'ai-sdk-ollama';` … [source]
```typescript — `import { ollama, generateText, streamText } from 'ai-sdk-ollama';` … [source]
```shell theme={"system"} — `curl http://localhost:11434/v1/messages \` … [source]
```shell theme={"system"} — `export COPILOT_PROVIDER_BASE_URL=http://localhost:11434/v1` … [source]
```shell theme={"system"} — `COPILOT_PROVIDER_BASE_URL=http://localhost:11434/v1 COPILOT_PROVIDER_API_KEY= COPILOT_PROVIDER_WIRE_API=respon` … [source]
```bash theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}} — `pip install -qU langchain-ollama` … [source]
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}} — `from langchain_ollama import ChatOllama` … [source]
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}} — `from langchain.messages import HumanMessage` … [source]
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}} — `from langchain_ollama import ChatOllama` … [source]
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}} — `llm = ChatOllama(model="llama3.1", logprobs=True, top_logprobs=3)` … [source]
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}} — `from langchain.messages import HumanMessage` … [source]
```bash theme={"system"} — `openclaw configure --section web` … [source]
```bash theme={"system"} — `openclaw configure --section channels` … [source]
```bash theme={"system"} — `openclaw gateway stop` … [source]
```bash theme={"system"} — `npm install -g @earendil-works/pi-coding-agent` … [source]
```bash theme={"system"} — `curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash` … [source]
```shell theme={"system"} — `claude --model qwen3.5` … [source]
```bash theme={"system"} — `npm install -g cline` … [source]
``` — `npm install -g @openai/codex` … [source]
```bash theme={"system"} — `nemoclaw my-assistant connect` … [source]
```shell theme={"system"} — `opencode` … [source]

Measurements and reference values

The Ollama launch blog recommends glm-4.7-flash (about 23 GB VRAM at 64k context), qwen3-coder and gpt-oss:20b locally, and cloud models such as glm-4.7:cloud, minimax-m2.1:cloud, gpt-oss:120b-cloud and qwen3-coder:480b-cloud. Later docs examples name newer models, so model recommendations date quickly. [source]
response = client.chat.completions.create( model='qwen3-vl:8b', messages=[ { 'role': 'user', 'content': [ {'type': 'text', 'text': "What's in this image?"}, { 'type': 'image_url', 'image_url': 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAG0AAABmCAYAAADBPx+VAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAA3VSURBVHgB7Z27r0zdG8fX743i1bi1ikMoFMQloXRpKFFIqI7LH4BEQ+NWIkjQuSWCRIEoULk0gsK1kCBI0IhrQVT7tz/7zZo888yz1r7MnDl7z5xvsjkzs2fP3uu71nNfa7lkAsm7d++Sffv2JbNmzUqcc8m0adOSzZs3Z+/XES4ZckAWJEGWPiCxjsQNLWmQsWjRIpMseaxcuTKpG/7HP27I8P79e7dq1ars/yL4/v27S0ejqwv+cUOGEGGpKHR37tzJCEpHV9tn [source]
const response = await openai.chat.completions.create({ model: "qwen3-vl:8b", messages: [ { role: "user", content: [ { type: "text", text: "What's in this image?" }, { type: "image_url", image_url: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAG0AAABmCAYAAADBPx+VAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAA3VSURBVHgB7Z27r0zdG8fX743i1bi1ikMoFMQloXRpKFFIqI7LH4BEQ+NWIkjQuSWCRIEoULk0gsK1kCBI0IhrQVT7tz/7zZo888yz1r7MnDl7z5xvsjkzs2fP3uu71nNfa7lkAsm7d++Sffv2JbNmzUqcc8m0adOSzZs3Z+/XES4ZckAWJEGWPiCxjsQNLWmQsWjRIpMseaxcuTKpG/7HP27I8P79e7dq1ars/yL4/v27S0ejqwv+cUOGEGGpKHR37tzJCEp [source]
If you have a recommendation for a model that runs on a Tesla V100 32gb card that would be fast and works better with tool calling in n8n. I’d be very happy to give it a try. [source]
```shell vision.sh theme={"system"} curl -X POST http://localhost:11434/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "qwen3-vl:8b", "messages": [{ "role": "user", "content": [{"type": "text", "text": "What is this an image of?"}, {"type": "image_url", "image_url": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAG0AAABmCAYAAADBPx+VAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAA3VSURBVHgB7Z27r0zdG8fX743i1bi1ikMoFMQloXRpKFFIqI7LH4BEQ+NWIkjQuSWCRIEoULk0gsK1kCBI0IhrQVT7tz/7zZo888yz1r7MnDl7z5xvsjkzs2fP3uu71nNfa7lkAsm7d++Sffv2JbNmzUqcc8m0adOSzZs3Z+ [source]
The STRIKE researchers identified 28,663 unique IP addresses hosting exposed OpenClaw control panels across 76 countries using live internet-wide reconnaissance. Of those, 12,812 instances were flagged as vulnerable to remote code execution, with 63% of observed deployments classified as exploitable. [source]

Problems, failure modes and limitations

OpenCode manual setup uses `opencode.json` with provider id ollama, npm package @ai-sdk/openai-compatible, options.baseURL http://localhost:11434/v1 and a models map. OpenCode's docs say Ollama can auto-configure OpenCode (pointing to the Ollama integration page) and advise, if tool calls fail, raising Ollama's `num_ctx` (start around 16k-32k). [source]
Context length: Ollama's blog and integration pages advise at least 64k tokens for coding agents; GitHub advises at least 128k for Copilot CLI BYOK; OpenCode's docs treat `num_ctx` (16k-32k start) as the first fix when tool calls fail. Ollama's default context is too small for these agents, so raise it before launching. [source]
Negation: a hands-on test (Ollama v0.15.1, Claude Code v2.1.15, M4 32GB) found small local models impractical with Claude Code: gemma3:4b returned an API error for no tool support, qwen2.5-coder:14b printed tool calls as JSON text and took 57s, and Claude Code's tool definitions alone use about 11,000 tokens of context. The author concluded it was 'not practical at this time'. Treat launch success as setup success, not capability. [source]
Hermes docs list gemma4:31b as the only model in their table with reliable tool calling (others chat-only); models without tool support cannot take actions. Long silence on first response is prefill of the large fixed prompt, documented as expected, not a hang. [source]
Antipattern: sharing one ollama-js client across streams you want to cancel independently; `abort()` kills every stream on the client, and a user issue requests built-in timeout cancellation and better error categories. [source]
Per an independent July 2026 guide, the Ollama Model node suits simple prompt-response in a Basic LLM Chain and cannot connect to the AI Agent node; agent workflows need the Ollama Chat Model node. The guide warns not every Ollama model does reliable function calling: smaller or older models may mangle tool calls, invent parameters or ignore tools. [source]
n8n offers two different sub-nodes for Ollama, and the choice directly determines whether your workflow can later call tools. The Ollama Model Node explicitly does not support tool-calling according to the documentation and therefore cannot be connected to the AI Agent Node; instead, it belongs to the Basic LLM Chain for simple prompt-response tasks without tool access. The Ollama Chat Model Node, on the other hand, is designed for conversation scenarios and connecting to agent workflows, and offers parameters such as Sampling Temperature, Top K, and Top P to control response diversity. You se [source]
Third-party guides report Ollama truncates over-long prompts silently, dropping early turns or the prompt prefix, which can remove retrieved RAG chunks or system instructions without any error. [source]
Local-model tool calling is less reliable than cloud models: guides report smaller or quantized models break JSON, drop required arguments or ignore tool instructions, and weak tool callers need precise tool names in prompts. This rests on guide-level reports, not benchmarks; the MCPHost-era advice to be specific about tool names reflects the same limit. [source]
The community stack coleam00/local-ai-packaged bundles n8n and Ollama with Supabase, Open WebUI, Flowise, Qdrant, Neo4j, SearXNG, Caddy and Langfuse via start_services.py profiles (gpu-nvidia, gpu-amd, cpu, none). In it n8n reaches Ollama at http://ollama:11434. On Apple Silicon Docker cannot use the GPU, so run Ollama natively with profile none and point the n8n credential at http://host.docker.internal:11434/. [source]
ollmcp reads tools, vision and thinking capabilities from Ollama, so a model without tool support is flagged. For non-Ollama (OpenAI-compatible) providers it assumes all three exist and an unsupported model returns an API error; those providers are marked experimental. The README lists gemma4, qwen3.5, lfm2.5-thinking, llama3.2 and mistral as working well. Snapshot: about 830 stars; star counts and versions differ across third-party listings. [source]
The error 'connect ECONNREFUSED ::1:11434' means the machine resolves localhost to IPv6 while Ollama listens on IPv4. Change the base URL to http://127.0.0.1:11434. [source]
This error occurs when your computer has IPv6 enabled, but Ollama is listening to an IPv4 address. [source]
Models must support tool calling (also called function calling) and streaming. If a model does not support either capability, Copilot CLI returns an error. For best results, use a model with a context window of at least 128k tokens. [source]
ollmcp (jonigl/mcp-client-for-ollama) is a Python 3.11+ terminal client for local Ollama models. It supports MCP tools, prompts and resources, STDIO, SSE and Streamable HTTP transports, multi-server connections, and human-in-the-loop approval of tool calls. Its agent mode loops tool calls up to a limit (default 7); a limit of 1 disables agent mode. [source]
How to connect n8n to local AI models via the Ollama credential, including a Docker pitfall and tool-calling limits. [source]
func chatWithQwen3Thinking(ctx context.Context, thinking bool) error { client, err := api.ClientFromEnvironment() // honors OLLAMA_HOST if set if err != nil { return err } [source]
Claude Code tries to use tools for file operations, etc., but gemma3:4b does not support native tool calls (function calling), resulting in an error. There is a possibility of handling this with custom prompt templates, but it cannot be used as-is with Claude Code. [source]
Claude Code is designed on the premise of complex system prompts and tool calls. Since tool definitions alone use approximately 11,000 tokens worth of context, small models of 8B or less cannot correctly process this enormous context. [source]
Capability detection limitation: ollmcp only reads real per-model capabilities (tools, vision, thinking) from Ollama. For every non-Ollama provider, all three capabilities are currently assumed available and shown as such in the model list and badges, so a model may be reported as supporting tools, vision, or thinking even when it doesn't. If a model lacks a capability, the provider's API will return an error when you try to use it. [source]
- Ollama's current versions are in the 0.x range but no such command exists - Claude Code cannot be connected to local models through Ollama in the way described - Claude Code uses Anthropic's API and does not have a feature to swap in local models this way [source]
When Ollama finishes, Open WebUI shows **success**, and the new model appears in the model selector as `pirate-gemma:latest`. If the JSON can't be read, the error is shown and nothing is sent. If the `from` model isn't on that server, Ollama tries to download it from Ollama.com instead and fails with **pull model manifest: file does not exist** when no such model exists there. [source]
HTTPS certificates for remote MCP servers are verified against your operating system trust store, not the certifi bundle. If an MCP server sits behind a private or corporate CA, or you run ollmcp in a minimal container with no system CA store, the TLS handshake fails with an error that does not mention ollmcp. Point SSL_CERT_FILE (a bundle file) or SSL_CERT_DIR (a directory) at your CA to fix it: [source]
func chatWithGptOss(ctx context.Context) error { client, err := api.ClientFromEnvironment() if err != nil { return err } req := &api.ChatRequest{ Model: "gpt-oss:20b", Think: api.Ptr(true), Messages: []api.Message{ {Role: "user", Content: "What is memoization and when is it useful?"}, }, } var resp api.ChatResponse if err := client.Chat(ctx, req, &resp); err != nil { return err } // If you intend to hide reasoning, do it here regardless of flags. if resp.Message.Thinking != "" { fmt.Println("🧠 thinking:\n", resp.Message.Thinking) } fmt.Println("\n💬 answer:\n", resp.Message.Content) return nil [source]
func generateWithQwen3(ctx context.Context) error { client, err := api.ClientFromEnvironment() if err != nil { return err } req := &api.GenerateRequest{ Model: "qwen3:4b-thinking", Prompt: "Summarize the role of a B-Tree in indexing.", Think: api.Ptr(true), } var resp api.GenerateResponse if err := client.Generate(ctx, req, &resp); err != nil { return err } if resp.Thinking != "" { fmt.Println("🧠 thinking:\n", resp.Thinking) } fmt.Println("\n💬 answer:\n", resp.Response) return nil } [source]
func generateWithGptOss(ctx context.Context) error { client, err := api.ClientFromEnvironment() if err != nil { return err } req := &api.GenerateRequest{ Model: "gpt-oss:20b", Prompt: "Explain gradient descent in simple terms.", Think: api.Ptr(true), } var resp api.GenerateResponse if err := client.Generate(ctx, req, &resp); err != nil { return err } if resp.Thinking != "" { fmt.Println("🧠 thinking:\n", resp.Thinking) } fmt.Println("\n💬 answer:\n", resp.Response) return nil } [source]
func streamWithOfficialSDK(ctx context.Context) error { client, _ := api.ClientFromEnvironment() [source]
func NewOllamaService() (*OllamaService, error) { client, err := api.ClientFromEnvironment() if err != nil { return nil, err } return &OllamaService{client: client}, nil } [source]
func loggedChat(ctx context.Context, logger *log.Logger, req *api.ChatRequest) error { start := time.Now() client, _ := api.ClientFromEnvironment() [source]
As well as RCE, OpenClaw instances are at risk of indirect prompt injection, whereby an attacker sends a target a message or places hidden text on a website containing malicious instructions. When the agent reads the message, it will faithfully follow these instructions – often without its owner being aware. [source]
config.yaml ReferenceMigrating Config to YAMLContinue Documentation MCP Serverconfig.json Reference (Deprecated)Context Providers (Deprecated)@Codebase (Deprecated)@Docs (Deprecated) [source]
HERMES_API_TIMEOUT=1800 # 30 minutes — generous for slow local models [source]

Comparisons and alternatives

Ollama's VS Code integration is the Ollama extension from the VS Code Marketplace, surfacing models in the Chat model picker; it needs VS Code 1.127 or newer and finds models at http://127.0.0.1:11434 by default. Ollama 0.17.6+ is recommended for cloud sign-in. [source]
For local models in VS Code, Ollama's docs say to set context length to at least 64k in Ollama Settings and reload the window; VS Code may display a model's maximum context while Ollama allocates less at runtime. This is a larger floor than Cline's 32K recommendation. [source]
Roo Code (while maintained) used Ollama's native API, read num_ctx from the Ollama model rather than setting it in the editor, and could run out of memory on first request because Ollama may allocate a larger context than expected. Fixes: pin num_ctx via Modelfile, preload with ollama run, use smaller quantizations, clear stale processes with ollama ps / ollama stop. [source]
Manual Hermes setup uses `hermes setup` -> Custom Endpoint with base URL `http://localhost:11434/v1`, or `model.provider: custom` and `model.base_url` in ~/.hermes/config.yaml. Using `--provider ollama` without `providers.ollama.base_url` fails with "provider 'ollama' has no endpoint configured" rather than falling back to OpenRouter. Hermes sets stream read timeout to 1800s for local endpoints; `HERMES_API_TIMEOUT=1800` goes in ~/.hermes/.env; `OLLAMA_KEEP_ALIVE=24h` avoids the 5-minute unload. [source]
* **OpenCode** - Open-source coding assistant * **Claude Code** - Anthropic's agentic coding tool * **Codex** - OpenAI's coding assistant * **VS Code** - Microsoft's IDE with built-in AI chat * **Droid** - Factory's AI coding agent [source]
Ai AI Coding Ai-Agents Alerting Anaconda Android API Architecture Aws AWS Amplify Backup Bash Cheatsheet Cloud Coding Community CookBook Cursor Data Database DeepLearning Dev Devops DGX Spark Digital Detox Docker Documentation Embeddings Filofax Flutter Git Gitea GitHub Go Golang Gpu Grafana Hardware Hermes Hosting Hugo Images Infrastructure Integration JavaScript K8S Knowledge-Management Kubernetes LabelStudio Latex Linux Llama.cpp Llamacpp Llm Logging Logseq Machine Learning Mainroad Markdown Melbourne Microservices Minio Mmdetection Monitoring Node.js NVidia ObjectDetection Observability Ob [source]
Open WebUI (an independent front-end) documents the failure signature of too little context with native function calling: tool schemas are injected into the prompt, and at 2048 tokens the model can return a blank response or emit a raw tool-call JSON blob instead of calling the tool. Its num_ctx control pre-fills 2048 and overrides the server's OLLAMA_CONTEXT_LENGTH; the fix is to raise context. [source]
An open-source Apache 2.0 AI coding agent for VS Code. Good choice for developers who prefer a simpler single-agent workflow without specialized agents. Kilo Code vs Cline comparison [source]
1. Open Roo Code in VS Code and click the **gear icon** on the top right corner of the Roo Code window to open **Provider Settings** 2. Set `API Provider` to `Ollama` 3. (Optional) Update `Base URL` if your Ollama instance is running remotely. The default is `http://localhost:11434` 4. Enter a valid `Model ID` (for example `qwen3` or `qwen3-coder:480b-cloud`. See all supported models [here](https://ollama.com/search)) 5. Adjust the `Context Window` to at least 32K tokens for coding tasks [source]
Honestly, tool-calling is the biggest weakness of local operation: not every model provided via Ollama supports reliable function calls, even if the Ollama Chat Model Node can technically be connected to a Tools Agent. Older or smaller models tend to format tool calls incorrectly, invent parameters, or simply ignore tools, which can lead to silent errors in production automations. Anyone who needs reliable tool-calling should specifically test models that were trained for it and spot-check the results before productive use instead of blindly trusting the output. For companies that need a solid [source]
The classic error occurs because each Docker container has its own localhost namespace, meaning n8n and Ollama in separate containers cannot reach each other automatically. If only Ollama runs in Docker and n8n runs directly on the host, it is enough to expose the port with -p 11434:11434 and keep http://localhost:11434 entered in n8n. If, on the other hand, n8n runs in a container and Ollama on the host system, you must use http://host.docker.internal:11434 instead of localhost in the Ollama credential. On Linux, the n8n container additionally requires the flag --add-host host.docker.internal [source]
In n8n sub-nodes (such as the Ollama chat model node), expressions like {{ $json.name }} always resolve to the first input item, unlike root nodes which resolve per item. [source]
Community reports (May 2026) say AI Agent workflows with local Ollama models often output tool schemas as plain text instead of executing tool calls (about 9 in 10 runs across ~10 models); qwen3.5 4b+ worked best but slowly. No cause was confirmed; suggested mitigations were a larger model, a LiteLLM proxy and checking tool schema format. [source]
When configuring [Ollama credentials](/integrations/builtin/credentials/ollama.md), use `host.docker.internal` as the host address instead of `localhost`. For example, to bind to the default port 11434, you could set the base URL to `http://host.docker.internal:11434`. [source]
When configuring [Ollama credentials](/integrations/builtin/credentials/ollama.md), use the Ollama container's name as the host address instead of `localhost`. For example, if you call the Ollama container `my-ollama` and it listens on the default port 11434, you would set the base URL to `http://my-ollama:11434`. [source]
To fix this, change the base URL in your [Ollama credentials](/integrations/builtin/credentials/ollama.md) to connect to `127.0.0.1`, the IPv4-specific local address, instead of the `localhost` alias that can resolve to either IPv4 or IPv6: `http://127.0.0.1:11434`. [source]
The default **Base URL** is `http://localhost:11434`, but if you've set the `OLLAMA_HOST` environment variable, enter that value. If you have issues connecting to a local n8n server, try `127.0.0.1` instead of `localhost`. [source]
If you'd rather drive Hermes's own wizard instead of `ollama launch hermes`, install it directly: [source]
<CardGroup> <Card title="VS Code" icon="https://mintcdn.com/ollama-9269c548/VdS6E00liu8o_Gkj/images/launch-icons/vscode.svg?fit=max&auto=format&n=VdS6E00liu8o_Gkj&q=85&s=a2ba239e0b0f44900813a438537a1c98" href="/integrations/vscode"> Install the Ollama extension to use models in VS Code Chat. </Card> </CardGroup> [source]
The Roo Code GitHub repository went read-only. The extension remains on the VS Code Marketplace in its final state but will not receive bug fixes or model updates. [source]
The new product being built by the former Roo Code team. Roomote is in early development as of May 2026 and has not shipped a public release. Kilo Code vs Roomote comparison [source]
What is the default context window in Ollama? Ollama configures a default context window of 4096 tokens across standard model instances. In earlier releases, the default was 2,048 tokens. When an incoming prompt and conversation history exceed this 4,096-token threshold, Ollama silently truncates the earliest messages to fit the budget without raising an error. You can check the current context allocation and memory distribution of active models using the ollama ps command in your terminal. How do I increase the context window in Ollama? You can increase the context window using three methods. [source]
This error message often occurs when n8n connects via IPv6 to the address ::1 instead of via IPv4 to 127.0.0.1, but Ollama only listens on the IPv4 address. Replace localhost with 127.0.0.1 in the base URL to fix the error. [source]
If the model prints raw JSON like {"name": "web_search", ...} in its reply instead of actually running the tool, that's usually the server, not the model — tool calling isn't enabled or the tool-call format isn't parsed. See the per-server fix table in Tool calls appear as text instead of executing (llama.cpp needs --jinja, vLLM needs --enable-auto-tool-choice --tool-call-parser hermes, and so on). [source]
Install [Roo Code](https://marketplace.visualstudio.com/items?itemName=RooVeterinaryInc.roo-cline) from the VS Code Marketplace. [source]
VS Code may show a model’s maximum supported context length even when Ollama allocates a smaller context at runtime. For local models, open Ollama Settings, set the context length to at least 64k, reload the VS Code window, and resend your prompt. See Context length for more information. [source]
VS Code may show a model's maximum supported context length even when Ollama allocates a smaller context at runtime. [source]
For local models, open Ollama **Settings**, set the context length to at least 64k, reload the VS Code window, and resend your prompt. See [Context length](/context-length) for more information. [source]
3. Provide your **Ollama API URL** and select your models. <Note>If you're running Onyx in Docker, to access your computer's local network use `http://host.docker.internal` instead of `http://127.0.0.1`.</Note> [source]
A context that is too small silently truncates the prompt. This is most visible with **Native function calling**, where tool schemas are injected into the prompt: at `2048` tokens the model can run out of room and return a **blank response**, or emit a raw tool-call JSON blob instead of actually calling the tool. Raising the context resolves it. [source]
While it runs, the dialog shows **Updating "model-name"** with a progress bar. **Cancel** stops the model that is downloading and skips the rest. If a model cannot be pulled, for example one you created yourself rather than downloaded from Ollama.com, the update skips it and moves on to the next one. When the run ends, Open WebUI shows **All models are up to date**. [source]
Use Ollama models in VS Code Chat with the Ollama extension. [source]
Earlier VS Code versions do not reliably cancel requests from language model providers. Ollama 0.17.6 or newer is recommended for cloud model sign-in and richer model metadata. Older versions may still work with local models. [source]
Install the Ollama extension from the VS Code Marketplace. [source]
Use Ollama models in VS Code Chat with the [Ollama extension](https://marketplace.visualstudio.com/items?itemName=Ollama.ollama). [source]
1. Install the [Ollama extension](https://marketplace.visualstudio.com/items?itemName=Ollama.ollama) from the VS Code Marketplace. 2. Open Chat in VS Code. 3. Open the model picker at the bottom of the chat input. 4. Choose a model from the **Ollama** section. [source]
OpenClaw, formerly known as Clawdbot and Moltbot, is an agentic artificial intelligence framework designed to run continuously and act on behalf of users. The software allows AI agents to execute commands, interact with external services, integrate with messaging platforms and operate with broad system-level permissions. It has become increasingly popular among developers, enterprises and individual users experimenting with autonomous assistants capable of performing real-world tasks rather than simply generating responses. [source]
2: I’m using the “Ai Agent” with a Tool node attached to it. The JSON tool schema is being produced by the model and pushed as text instead of being picked up as a Tool call by the Tool node. If n8n has a specific Tool Schema I need to direct the model to use, I’m not aware of it. [source]
The same problem occurred with 14B as well. Instead of writing code, it tried to create a task list, and the tool call was output as JSON text. Processing time was also slow at 57 seconds, and increasing the model size did not resolve the integration issues with Claude Code. [source]

Changes and history

Roo Code founder Matt Rubens announced the project would archive. The Roo Code extension had accumulated 3M+ VS Code installs. [source]
Roo Code archived its repository on May 15, 2026. The team behind it is now building a new product called Roomote. If you used Roo Code or are evaluating Roomote, here's what happened and what your best options are today. [source]

Facts and statements

Claude Code manual setup against local Ollama: export ANTHROPIC_AUTH_TOKEN=ollama, ANTHROPIC_API_KEY="" and ANTHROPIC_BASE_URL=http://localhost:11434, then `claude --model <model>`. For Ollama's cloud without a local install, set ANTHROPIC_BASE_URL=https://ollama.com with ANTHROPIC_AUTH_TOKEN=$OLLAMA_API_KEY. Hosted WebSearch and advanced tool controls are not fully supported through Ollama's Anthropic compatibility, and Claude settings files can override shell variables (check with /status). [source]
ollama launch pi` installs Pi if needed, configures Ollama as a provider including web tools (`@ollama/pi-web-search`), and opens a session; `--config` configures only, `--model qwen3.5:cloud` picks a model. Pi ships four core tools (read, write, edit, bash); everything else comes from extensions. [source]
JetBrains IDEs connect to Ollama via the AI chat sidebar: Set up Local Models, Third Party AI Providers, Ollama, Host URL http://localhost:11434. Ollama's page says a JetBrains AI Subscription is required. [source]
GitHub's official Copilot CLI BYOK docs list Ollama as a supported OpenAI-compatible provider. Env vars: COPILOT_PROVIDER_BASE_URL (required), COPILOT_MODEL (required, or --model), COPILOT_PROVIDER_TYPE (openai default, azure, anthropic), COPILOT_PROVIDER_API_KEY (optional; a local Ollama needs none), COPILOT_PROVIDER_WIRE_API, and COPILOT_PROVIDER_MAX_PROMPT_TOKENS / MAX_OUTPUT_TOKENS. Models must support tool calling and streaming or the CLI errors. [source]
Codex manual paths: `codex --oss` (optionally `-m <model>`), or a persistent profile `~/.codex/ollama-launch.config.toml` with model_provider "ollama-launch", base_url http://localhost:11434/v1/ and wire_api = "responses". Codex's own repo made the Responses format the default for the built-in `ollama` provider (#8798), and a third-party guide reports the chat-completions wire API was removed from Codex in February 2026, so `wire_api = "chat"` configs no longer work. [source]
Codex web-search requests sent through the Ollama profile are executed by Ollama for local and cloud models and need `ollama signin`; disable with `codex --profile ollama-launch -c 'web_search="disabled"'`. [source]
As of the docs mirror, `ollama launch` supports Claude Code (`ollama launch claude`), Codex (`ollama launch codex`), OpenCode (`ollama launch opencode`) and Copilot CLI (`ollama launch copilot`); the list has grown past the four launch-day tools (Droid, DeepSeek Harness `dsh` and others). Check `ollama launch --help` for the live list. [source]
ollama launch` was announced in the Ollama blog on 2026-01-23 with Claude Code, OpenCode, Codex and Droid as supported tools; the blog presents it as setup-and-run with no manual environment variables or config files, and `--config` configures a tool without launching it. [source]
ollama launch openclaw` installs OpenClaw via npm if missing, shows a security notice, lets the user pick a model, configures the provider, installs the gateway daemon, enables bundled Ollama web search, then opens the OpenClaw TUI. `--config` changes the model without starting; `--model X --yes` is headless and auto-pulls (requires --model). `ollama launch clawdbot` remains an alias (OpenClaw's former name). [source]
ollama launch hermes` installs the Hermes CLI agent if absent, lets the user choose a local or cloud model, configures the Ollama provider against the local OpenAI-compatible endpoint, optionally connects a messaging gateway, then starts Hermes chat. Later changes use `hermes model`; messaging uses `hermes gateway setup`. [source]
Cline against Ollama cloud: enable Use custom base URL, set https://ollama.com, enter an ollama.com API key, and choose a cloud model that supports tool calling. [source]
Across editors, remote Ollama needs the client's base URL changed from localhost; Continue also needs OLLAMA_HOST=0.0.0.0:11434 on the server, and Roo's docs flag the base URL change for other machines. [source]
Manual Pi config: ~/.pi/agent/models.json gets an `ollama` provider with base URL http://localhost:11434/v1, api `openai-completions`, key `ollama`; ~/.pi/agent/settings.json sets the default provider and model. Ollama's page names the package `@earendil-works/pi-coding-agent`. [source]
Ollama ships its own MCP server example: a Python script (ollama-python examples/web-search-mcp.py) that exposes Ollama web search and fetch to any MCP client. It runs over stdio via uv with OLLAMA_API_KEY in env. Ollama's docs show configs for Cline (mcpServers JSON) and Codex (~/.codex/config.toml [mcp_servers.web_search]), and say Goose connects through its MCP feature. [source]
Headless use: `ollama launch claude --model <m> --yes -- -p "..."` (same shape for `copilot`). `--yes` skips selectors, pulls the model if missing, and requires `--model`; everything after `--` goes straight to the underlying tool. [source]
Codex via `ollama launch codex` refreshes the model catalog and uses a dedicated Codex profile for the session; `--config` configures without launching and `--restore` removes the Ollama launch profile and generated catalog. In Codex, `/model` switches between installed tool-capable Ollama models without a restart. [source]
Copilot CLI `COPILOT_OFFLINE=true` stops contact with GitHub's servers, but it only gives full network isolation if the provider is also local; a remote COPILOT_PROVIDER_BASE_URL still receives prompts and code context. [source]
Zed configures Ollama under language_models.ollama with api_url, auto_discover (default on), and available_models entries (name, display_name, max_tokens, supports_tools, supports_thinking, supports_images). Remote Ollama (cloud) uses api_url https://ollama.com plus an API key or OLLAMA_API_KEY. [source]
Zed sends context length to Ollama as num_ctx with a default of 4096 tokens; raise it globally with context_window or per model with max_tokens. External Agents, terminal threads and Edit Prediction are configured separately. [source]
ollama-js supports tools (`tools`, `tool_name` for results), `think` (boolean or level), `webSearch`/`webFetch` (need an Ollama account and API key), and `abort()`, which cancels all streams on that client; for per-stream cancellation use one client per stream. [source]
Continue's Ollama guide warns agent mode needs tool support, which some models (e.g. DeepSeek R1) report as unsupported even with capabilities: [tool_use]; Continue may default to a large context causing memory errors, so lower contextLength. The guide was written against Ollama v0.11.x and Continue v1.1.x, so details may be dated. [source]
Both Python and JS clients can use Ollama cloud models two ways: through a local Ollama after `ollama signin`, or directly by setting host to https://ollama.com with an OLLAMA_API_KEY bearer token. [source]
OpenClaw's Ollama provider supports three setups: Cloud + Local (an Ollama host serving local models and, if signed in, :cloud models), Local only, and direct Ollama Cloud at https://ollama.com via the `ollama-cloud` provider with no daemon (model refs `ollama-cloud/<model>`). [source]
Third-party wrapper check: ai-sdk-ollama, a community Vercel AI SDK provider by a non-Ollama author, states it is 'built on the official `ollama` package' (ollama-js), accepts an existing Ollama client instance, and adds tool-call follow-up text, JSON repair and web search/fetch tools needing OLLAMA_API_KEY. Each major version targets one AI SDK major (4.x targets ai@^7, 3.x ai@^6 maintenance only, 2.x unmaintained). [source]
ollama-js installs with `npm i ollama`; Node uses `import ollama from 'ollama'` and browsers use `import ollama from 'ollama/browser'`. A custom `new Ollama({host, fetch, headers})` replaces the default host http://127.0.0.1:11434. [source]
A newer System One endpoint (structured multiple-choice, yes/no, scored answers) appears in all three clients and needs Ollama server v0.35.0+; in ollama-js it needs a compatible model and does not support streaming or cloud models. [source]
Ollama recommends a context window of at least 64k tokens for OpenClaw with local models; the Hermes docs state Hermes requires at least 64,000 tokens for agentic work with tools and that Ollama defaults to 2048. Hermes fix: a Modelfile with `PARAMETER num_ctx 64000` and `ollama create`, then point Hermes at the new model. [source]
ollama-python installs with `pip install ollama`, supports Python 3.8+, and offers a sync `Client` and an `AsyncClient`; extra keyword arguments are passed through to httpx, and `stream=True` returns a generator (async generator for AsyncClient). [source]
PyPI lists ollama 0.6.3 (released 2026-09-29) as the latest Python client version. [source]
The Go api package exposes Pull, Push, Create, Copy, Delete, List, Show, ListRunning, Version, Heartbeat, Embed, Whoami and Signout; web fetch/search, cloud status, model recommendations and SystemOne are marked Experimental, so their signatures may change. pkg.go.dev showed v0.40.4 (2026-10-13) with a note that it was not the module's latest tag. [source]
For production Go code an independent write-up (Oct 2025) recommends the official api package; LangChainGo suits chain/RAG pipelines, and community clients vary in coverage. Thinking-model quirks (GPT-OSS not disabling thinking, interleaved reasoning in streams) apply regardless of client. [source]
OpenClaw has a serious exposure record: SecurityScorecard STRIKE counted ~40,000 internet-reachable instances in early Feb 2026, with reported RCE-exploitable hosts. Treat any OpenClaw on Ollama as needing a loopback-only gateway and sandboxing. [source]
I do have to point out that MCP calling does work fine in opencode and in open webui with some of the models that didn’t seem to work in n8n. I have a hard time blaming the model in this case but I am open to the “out-of-spec” issue as thats fairly common in engineering and I do deal with this quite a bit. [source]
n8n connects to Ollama via its own Ollama credential, in which you only need to enter a base URL (default: http://localhost:11434) and optionally an API key. Local language models can then be integrated into workflows via the Ollama Model Node or the Ollama Chat Model Node, without prompt data being sent to a cloud provider. The Ollama Model Node is suitable for simple chains with the Basic LLM Chain, but according to the n8n documentation it does not support tool-calling. For AI agents with tool access, the Ollama Chat Model Node is the right choice, although not every local model reliably ha [source]
LlamaIndex's Ollama LLM class (llama-index-llms-ollama) defaults base_url to http://localhost:11434, takes context_window=-1 (read from model info via the client, else a DEFAULT_CONTEXT_WINDOW constant), and has a thinking option (bool or low/medium/high) and a json_mode flag. [source]
Context-length trap: Ollama's server default context depends on VRAM (under 24 GiB: 4k; 24-48 GiB: 32k; 48 GiB or more: 256k) and its docs recommend at least 64000 tokens for agents, web search and coding tools. Set num_ctx in ChatOllama or context_window/additional_kwargs in LlamaIndex, or OLLAMA_CONTEXT_LENGTH on the server, and check with ollama ps. [source]
<Tabs> <Tab title="Claude Code"> ```shell theme={"system"} ollama launch claude ``` [source]
```shell theme={"system"} ollama launch codex ``` [source]
<Tab title="OpenCode"> ```shell theme={"system"} ollama launch opencode ``` [source]
ollmcp works with Ollama plus any OpenAI-compatible provider that any-llm exposes. Select one with --provider. Provide the key with --api-key or $OLLMCP_API_KEY (both work for any selected provider) or via the provider's own environment variable shown below. $OLLMCP_API_KEY and the provider-native env vars are never written to disk; only a key passed with --api-key is saved to the config. [source]
The Ollama Chat Model node supports Bearer token authentication for connecting to remote Ollama instances behind authenticated proxies (such as Open WebUI). [source]
Just to set the context of this. I am a extremely technical person. I run my own lab at my house. I have n8n running in a docker on my TrueNAS Scale server. I am using Ollama for inference locally. I run other AI tools without issues such as Opencode and Open WebUI. [source]
1. **Install** — If OpenClaw isn't installed, Ollama prompts to install it via npm 2. **Security** — On the first launch, a security notice explains the risks of tool access 3. **Model** — Pick a model from the selector (see supported local and cloud models [here](https://ollama.com/search)) 4. **Onboarding** — Ollama configures the provider, installs the gateway daemon, sets your model as the primary, and enables OpenClaw's bundled Ollama web search 5. **Gateway** — Starts in the background and opens the OpenClaw TUI [source]
codex --profile ollama-launch -c 'web_search="disabled"' [source]
2: Really really bad Ollama support. I have tried around 10 different models and very few work properly with the “AI Agent” backed with a Ollama model. I have multiple MCP servers connected as tools via MetaMCP and 9 time out of 10, n8n does not manage the tool calling correctly and just dumps the tool calling into text and pushing the workflow forward. [source]
No, according to the n8n documentation, the Ollama Model Node lacks tool support, which is why it does not work with the AI Agent Node. For agent workflows with tool access, use the Ollama Chat Model Node instead, but you must check the tool-calling capability of the chosen model yourself. [source]
ChatOllama has a reasoning parameter: True returns reasoning separately in additional_kwargs reasoning_content, False disables it, None (default) leaves model behavior so think tags may appear in the main content. It can be set per call. [source]
LlamaIndex embeds via a separate package, llama-index-embeddings-ollama (OllamaEmbedding, subclass of BaseEmbedding); LangChain uses OllamaEmbeddings inside langchain-ollama. The LlamaIndex docs example uses embeddinggemma (768-dim vectors). [source]
For a persistent Codex CLI configuration, create `~/.codex/ollama-launch.config.toml`: [source]
[model_providers.ollama-launch] name = "Ollama" base_url = "http://localhost:11434/v1/" wire_api = "responses" [source]
ANTHROPIC_BASE_URL=https://ollama.com \ ANTHROPIC_AUTH_TOKEN="$OLLAMA_API_KEY" \ ANTHROPIC_API_KEY="" \ claude --model glm-5.3-flash [source]
ChatGPT Desktop includes Codex, OpenAI's desktop coding agent. Ollama adds compatible local and cloud models to Codex's model picker alongside ChatGPT's native models. [source]
n8n's Ollama credential supports only the Instance URL method. Fields are Base URL (default http://localhost:11434) and an optional API key sent as a Bearer token in the Authorization header, meant for authenticated remote proxies such as Open WebUI. The credential serves the Ollama, Chat Ollama and Embeddings Ollama nodes. [source]
OpenClaw ships with a bundled Ollama `web_search` provider that lets local or cloud-backed Ollama setups search the web through the configured Ollama host. [source]
Claude Code reads your codebase, edits files, and runs commands. Ollama connects Claude Code to local and cloud models through its Anthropic-compatible API. [source]
ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY="" claude --model kimi-k2.7-code:cloud [source]
The LangChain Ollama integration lives in the `langchain-ollama` package: [source]
Ollama connects Claude Code to local and cloud models through its Anthropic-compatible API. [source]
3. Set the API base URL to the Ollama OpenAI-compatible endpoint: [source]
<Card title="ChatGPT Desktop" icon="https://mintcdn.com/ollama-9269c548/HSXjoAUgp7vt8Q9k/images/launch-icons/chatgpt.svg?fit=max&auto=format&n=HSXjoAUgp7vt8Q9k&q=85&s=c1abef5f71760198760f4cb7669ef143" href="/integrations/chatgpt"> Use Ollama models in Codex mode. </Card> </CardGroup> [source]
ollama launch copilot --model kimi-k2.5:cloud [source]
ollama launch copilot --model kimi-k2.5:cloud --yes -- -p "how does this repository work?" [source]
{ "$schema": "https://opencode.ai/config.json", "provider": { "ollama": { "npm": "@ai-sdk/openai-compatible", "name": "Ollama", "options": { "baseURL": "http://localhost:11434/v1" }, "models": { "qwen3.5": { "name": "qwen3.5" } } } } } [source]
ollama launch opencode starts OpenCode with an inline config for the selected Ollama model. It does not overwrite ~/.config/opencode/opencode.json; existing OpenCode settings still apply. Models defined only in opencode.json do not appear in the ollama launch model picker. See OpenCode’s config precedence. Previous [source]
<Note>Previously known as Clawdbot. `ollama launch clawdbot` still works as an alias.</Note> [source]
ollama launch claude --model gemma4:cloud --yes -- -p "how does this repository work?" [source]
ollama launch claude -- --channels plugin:telegram@claude-plugins-official [source]
Ollama v0.15 does not exist, and there is no `ollama launch claude` command. [source]
With the release of Ollama v0.15 on January 23, 2026, the ollama launch claude command was added. This makes it very easy to set up Claude Code to run on local models. I was excited and tested it with the expectation that "maybe we can finally use Claude Code with a local LLM," but to get straight to the point, it was not practical at this time. [source]
In v0.15, the ollama launch claude command was added, eliminating the need to set environment variables. [source]
ollama launch claude --model qwen2.5-coder:1.5b [source]
Ollama can automatically configure itself for OpenCode. See the Ollama integration docs for details. [source]
* [Integrations](/integrations) — connect an app, editor, or agent. * [API reference](/api/introduction) — use Ollama's API or compatible OpenAI and Anthropic clients. * [Python library](https://github.com/ollama/ollama-python) and [JavaScript library](https://github.com/ollama/ollama-js) — use Ollama from your application. [source]
`ollama launch opencode` starts OpenCode with an inline config for the selected Ollama model. It does not overwrite `~/.config/opencode/opencode.json`; existing OpenCode settings still apply. [source]
Models defined only in `opencode.json` do not appear in the `ollama launch` model picker. [source]
☁️ Ollama Cloud Support: Works seamlessly with Ollama Cloud models for tool calling, enabling access to powerful cloud-hosted models while using local MCP tools [source]
MCP Client for Ollama now supports Ollama Cloud models, allowing you to use powerful cloud-hosted models with tool calling capabilities while leveraging your local MCP tools. Cloud models can run without a powerful local GPU, making it possible to access larger models that wouldn't fit on a personal computer. [source]
``` API base URL [e.g. https://api.example.com/v1]: http://127.0.0.1:11434/v1 ``` [source]
5. Hermes auto-detects downloaded models, confirm the one you want: [source]
``` Verified endpoint via http://127.0.0.1:11434/v1/models (1 model(s) visible) Detected model: kimi-k2.5:cloud Use this model? [Y/n]: ``` [source]
6. Leave context length blank to auto-detect: [source]
``` Context length in tokens [leave blank for auto-detect]: ``` [source]
Documentation for common issues and questions in the Ollama Chat Model node in n8n, a workflow automation platform. Includes details of the issue and suggested solutions. [source]
Here are some common errors and issues with the [Ollama Chat Model node](/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatollama.md) and steps to resolve or troubleshoot them. [source]
Learn how to use the Ollama Chat Model node in n8n. Follow technical documentation to integrate Ollama Chat Model node into your workflows. [source]
The Ollama Chat Model node allows you use local Llama 2 models with conversational agents[^1]. [source]
On this page, you'll find the node parameters for the Ollama Chat Model node, and links to more resources. [source]
N8n + Ollama + Thinking + MCP servers = very bad experience [source]
Ollama Model Node or Ollama Chat Model Node: which node do you need? [source]
Ollama’s web search can be integrated with Cline easily using the MCP server configuration. Manage MCP Servers > Configure MCP Servers > Add the following configuration: [source]
1. In marimo, go to the user settings and go to the AI tab. From here you can find and configure Ollama as an AI provider. For local use you would typically point the base url to `http://localhost:11434/v1`. [source]
MCPHost config uses an mcpServers key (YAML or JSON) with stdio, streamable and inprocess transports (sse only in the legacy format), ${env://VAR} substitution, and per-server allowedTools or excludedTools (one of the two per server). Ollama models must support function calling. [source]
- **Reliable tool calling** - Response synthesis adds text after tool execution, so you don't get empty replies - **Wrapper functions** - `generateText` and `streamText` return complete responses - **Built-in reliability** - Reliability features run by default - **Automatic JSON repair** - Cascade repair runs [jsonrepair](https://github.com/josdejong/jsonrepair) first, then an Ollama-specific fallback for trailing commas, comments, URLs, and Python constants - **Web search and fetch** - Built-in tools powered by [Ollama's web search API](https://ollama.com/blog/web-search) for current informat [source]
<Card title="Hermes Agent" icon="https://mintcdn.com/ollama-9269c548/VdS6E00liu8o_Gkj/images/launch-icons/hermes-agent.svg?fit=max&auto=format&n=VdS6E00liu8o_Gkj&q=85&s=23dcf989a34d894a97bdb847c3831057" href="/integrations/hermes"> Personal assistant with memory, reusable skills, and messaging. </Card> </CardGroup> [source]
Open WebUI shows a green "Loaded" indicator next to any Ollama model that is currently kept warm by the runtime, and admins see an **Eject** button on the model row to unload it without restarting the server. Behind the scenes, Open WebUI calls `POST /api/models/unload` (admin-only), which forwards a `keep_alive=0` generate call to every Ollama node serving that model. [source]
model = "gpt-oss:120b" model_provider = "ollama-launch" model_catalog_json = "~/.codex/model.json" [source]
Im interested in both sides: "pure" ollama.js and openai compatible ollama js library. [source]
N8N_HOSTNAME=n8n.yourdomain.com WEBUI_HOSTNAME=:openwebui.yourdomain.com FLOWISE_HOSTNAME=:flowise.yourdomain.com SUPABASE_HOSTNAME=:supabase.yourdomain.com OLLAMA_HOSTNAME=:ollama.yourdomain.com SEARXNG_HOSTNAME=searxng.yourdomain.com NEO4J_HOSTNAME=neo4j.yourdomain.com LETSENCRYPT_EMAIL=your-email-address [source]
You can configure opencode to use local models through Atomic Chat, a desktop application that runs local LLMs behind an OpenAI-compatible API server (default endpoint http://127.0.0.1:1337/v1). [source]
const client = new Ollama(); const results = await client.webSearch("what is ollama?"); console.log(JSON.stringify(results, null, 2)); [source]
const client = new Ollama(); const fetchResult = await client.webFetch("https://ollama.com"); console.log(JSON.stringify(fetchResult, null, 2)); [source]
Connect Anthropic clients and tools such as Claude Code to Ollama. Ollama supports a subset of the [Anthropic Messages API](https://platform.claude.com/docs/en/api/http/messages/create). [source]
1. Sign in to Ollama's cloud with `ollama signin` 2. In the ollama model settings add a model that ollama hosts, like `gpt-oss:120b`. 3. You can now refer to this model in marimo! [source]
```shell tools.sh theme={"system"} curl -X POST http://localhost:11434/v1/messages \ -H "Content-Type: application/json" \ -d '{ "model": "qwen3-coder", "max_tokens": 1024, "tools": [ { "name": "get_weather", "description": "Get the current weather in a location", "input_schema": { "type": "object", "properties": { "location": { "type": "string", "description": "The city and state" } }, "required": ["location"] } } ], "messages": [{ "role": "user", "content": "What is the weather in San Francisco?" }] }' ``` </CodeGroup> [source]
<Note>Use a context window of at least 64k tokens for Codex.</Note> [source]
Ollama offers to install Claude Code if needed. See [Claude Code](/integrations/claude-code) for details. </Tab> [source]
Ollama offers to install OpenCode if needed. See [OpenCode](/integrations/opencode) for details. </Tab> </Tabs> [source]
Copilot CLI connects to Ollama using the OpenAI-compatible API via environment variables. [source]
Local OpenAI-compatible servers (ollama, llamacpp, llamafile, lmstudio, vllm) typically run without an API key, point ollmcp at them with --host. Providers any-llm offers that are not OpenAI-compatible (e.g. anthropic, gemini, mistral, groq, cohere) are not supported yet. [source]
The official SDK automatically respects OLLAMA_HOST via api.ClientFromEnvironment(). [source]
You can configure Copilot CLI to include models from an LLM provider of your choice—using BYOK (Bring Your Own Key)—in addition to the GitHub-hosted models. This lets you connect to OpenAI-compatible endpoints, Azure OpenAI, or Anthropic, including locally running models such as Ollama. [source]
OpenClaw talks to Ollama's native API (/api/chat), not the OpenAI-compatible /v1 endpoint. Three setups are supported: [source]
Pi can use web search and fetch tools via the `@ollama/pi-web-search` package. [source]
Ollama can be integrated into most of the tools available either through direct integration of Ollama’s API, Python / JavaScript libraries, OpenAI compatible API, and MCP server integration. Previous [source]
Ollama has no built-in MCP client. Bridges (ollmcp, MCPHost, DIY scripts) discover MCP tools, convert their schemas into the tools format Ollama's chat API accepts, and execute the tool calls the model requests. [source]
MCPHost (mark3labs/mcphost), a Go CLI host that runs Ollama models against MCP servers (flag form -m ollama/qwen2.5:3b, base URL via OLLAMA_HOST), is archived and read-only. The maintainers point to its successor Kit. Older tutorials that install it with go install now point at an unmaintained tool. [source]
For this setup, open a specific port for n8n to communicate with Ollama by setting the `OLLAMA_ORIGINS` variable or adjusting `OLLAMA_HOST` to an address the other container can access. [source]
The project scope writes a standard .mcp.json file at your project root, compatible with Claude Code and other MCP-aware tools. If the same server name exists in multiple scopes, precedence is local > project > user. [source]
If you're looking for an alternative, check out ZooCode (a fork started by the Roo Code community) and Cline (from where Roo Code originated). [source]
If you're running OLLAMA locally on your Mac (not in Docker), you need to modify the OLLAMA_HOST environment variable in the n8n service configuration. Update the x-n8n section in your Docker Compose file as follows: [source]
const ollama = new Ollama({ host: 'http://127.0.0.1:11434' }) const response = await ollama.chat({ model: 'llama3.1', messages: [{ role: 'user', content: 'Why is the sky blue?' }], }) [source]
const ollama = new Ollama({ host: 'http://127.0.0.1:11434', headers: { Authorization: 'Bearer <api key>', 'X-Custom-Header': 'custom-value', 'User-Agent': 'MyApp/1.0', }, }) [source]
Ollama can integrate with Goose via its MCP feature. [source]
Choose a [cloud model](https://ollama.com/search?c=cloud) that supports tools. Basic chat and file edits work with compatible models. Hosted WebSearch and advanced tool controls are not fully supported. See [Anthropic compatibility](/api/anthropic-compatibility). [source]
NemoClaw is NVIDIA's open source security stack for [OpenClaw](/integrations/openclaw). It wraps OpenClaw with the NVIDIA OpenShell runtime to provide kernel-level sandboxing, network policy controls, and audit trails for AI agents. [source]
4. Leave the API key blank (not required for local Ollama): [source]
client = OpenAI( base_url='http://localhost:11434/v1/', api_key='ollama', # required but ignored ) [source]
const openai = new OpenAI({ baseURL: "http://localhost:11434/v1/", apiKey: "ollama", // required but ignored }); [source]
If only n8n runs in Docker, set Ollama to bind 0.0.0.0 on the host and use http://host.docker.internal:11434 as base URL. On Linux without Docker Desktop, start n8n with --add-host host.docker.internal:host-gateway (or compose extra_hosts host.docker.internal:host-gateway). [source]
If n8n and Ollama run in separate containers, use the Ollama container name as host (e.g. http://my-ollama:11434) and make sure Ollama binds 0.0.0.0. If only Ollama is in Docker, publish -p 11434:11434 and keep localhost. [source]
Ollama's docs describe connecting n8n to Ollama Cloud: create an API key on ollama.com, add an Ollama credential in n8n, set API URL to https://ollama.com and paste the key. The n8n credential page does not mention Ollama Cloud. [source]
Ollama's default context length depends on VRAM: 4k tokens under 24 GiB, 32k at 24-48 GiB, 256k at 48 GiB or more. Ollama recommends at least 64,000 tokens for web search, agents and coding tools; set it with OLLAMA_CONTEXT_LENGTH=64000 ollama serve or the app slider. MCP tool schemas and results compete for this window, so a bridge on a small default context can degrade. [source]
Ollama typically listens for connections on `localhost`, the local network address. In Docker, by default, each container has its own `localhost` which is only accessible from within the container. If either n8n or Ollama are running in containers, they won't be able to connect over `localhost`. [source]
If Ollama and n8n are running in the same Docker container, the `localhost` address doesn't need any special configuration. You can configure Ollama to listen on localhost and configure the base URL in the [Ollama credentials in n8n](/integrations/builtin/credentials/ollama.md) to use localhost: `http://localhost:11434`. [source]
GitHub Copilot CLI is GitHub’s AI coding agent for the terminal. It can understand your codebase, make edits, run commands, and help you build software faster. Open models can be used with Copilot CLI through Ollama, enabling you to use models such as qwen3.5, glm-5.3:cloud, kimi-k3:cloud See all supported models here. [source]
Roo Code behavior: Roo automatically uses whatever num_ctx is configured in your Ollama model [source]
Harness the power of local LLMs with this TUI MCP Client for Ollama. Featuring all core MCP primitives (tools, prompts, resources), agent mode, multi-server, model switching, streaming responses, human-in-the-loop, thinking mode, model params config, system prompts, and saved preferences. [source]
A simple yet powerful Python client for interacting with Model Context Protocol (MCP) servers using Ollama, allowing you to harness local LLMs for advanced tool execution. [source]
Codex web-search requests sent through the Ollama profile are executed by Ollama for both local and cloud models. Sign in with ollama signin to use the web-search service. To disable web search for a Codex session: [source]
/ Ollama Context Window: Default Limits, num_ctx Tuning, and MCP Search [source]
Ollama Context Window: Default Limits, num_ctx Tuning, and MCP Search [source]
Stop forcing massive file corpuses into your local Ollama context window. Index your documents in an intelligent Fast.io workspace, connect your assistant through the remote MCP server, and retrieve exact context chunks on demand. Monthly plans start with a trial of up to 14 days (credit card required); annual plans have no trial. [source]
Official Ollama Go package — Go SDK documentation [source]
Why does n8n report "ECONNREFUSED" even though Ollama is running? [source]
Download my N8N + OpenWebUI integration directly on the Open WebUI site. (more instructions below) [source]
On the Hermes desktop app, Settings → Providers → Local Models installs and manages a local llama.cpp server for you — model downloads, memory fitting, and context sizing included. See Local Models. This guide is for manual setup: Ollama specifically, CLI-first workflows, or servers you want to run yourself. [source]
You'll set up Hermes Agent running entirely on your own hardware, using Ollama as the model backend. No API keys, no subscriptions, no data leaving your machine. Once configured, Hermes works exactly like it does with OpenRouter or Anthropic — terminal commands, file editing, web browsing, delegation — but the model runs locally. [source]
1. Open the Ollama desktop app and select **Apps**. 2. Toggle **ChatGPT (Desktop)** to On. 3. Follow the setup prompts. If ChatGPT is already open, Ollama asks to restart it before the new models appear. 4. Open the ChatGPT desktop app and use Codex mode. [source]
1. Open Cline settings > `API Configuration` and set `API Provider` to `Ollama` 2. Select a model under `Model` or type one (e.g. `qwen3`) 3. Update the context window to at least 32K tokens under `Context Window` [source]
Type `/model` inside Codex to switch between your installed, tool-capable Ollama models without restarting. The starting model remains selected, and each model keeps its own context window, vision, and thinking settings. Pull additional models with `ollama pull <model>` before launching to include them in the picker. [source]
Codex web-search requests sent through the Ollama profile are executed by Ollama for both local and cloud models. Sign in with `ollama signin` to use the web-search service. [source]
1. **Install** - If Hermes isn't installed, Ollama prompts to install the Hermes command-line agent. On first desktop launch, Hermes builds its packaged desktop app. 2. **Model** - Pick a model from the selector 3. **Configure** - Ollama configures Hermes Desktop to use your selected Ollama model 4. **Launch** - Ollama opens Hermes Desktop [source]
Ollama configures OpenCode to use local and cloud models. [source]
* [Claude Desktop](/integrations/claude-desktop) — use Ollama models in Claude. * [ChatGPT Desktop](/integrations/chatgpt) — use Ollama models in Codex mode. Regular Chat and voice use your usual ChatGPT connection. [source]
client = anthropic.Anthropic( base_url='http://localhost:11434', api_key='ollama', ) [source]
const anthropic = new Anthropic({ baseURL: "http://localhost:11434", apiKey: "ollama", }); [source]
2. Find **Ollama**, click **Configure** 3. Confirm **API Host** is `http://localhost:11434` and click Submit [source]
<CardGroup> <Card title="Claude Code" icon="https://mintcdn.com/ollama-9269c548/VdS6E00liu8o_Gkj/images/launch-icons/claude-code.svg?fit=max&auto=format&n=VdS6E00liu8o_Gkj&q=85&s=edd8f01fa1844a0eca0a9e00be74a8a3" href="/integrations/claude-code"> Read code, edit files, and run commands. </Card> [source]
<Card title="OpenCode" icon="https://mintcdn.com/ollama-9269c548/VdS6E00liu8o_Gkj/images/launch-icons/opencode.svg?fit=max&auto=format&n=VdS6E00liu8o_Gkj&q=85&s=ffa7d783e8ddf476a376ebbedaa064ae" href="/integrations/opencode"> Edit and run code from your terminal. </Card> [source]
<CardGroup> <Card title="OpenClaw" icon="https://mintcdn.com/ollama-9269c548/VdS6E00liu8o_Gkj/images/launch-icons/openclaw.svg?fit=max&auto=format&n=VdS6E00liu8o_Gkj&q=85&s=41b25b9a809d087e9e55b1b7bdb76cae" href="/integrations/openclaw"> Chat with an assistant through your messaging apps. </Card> [source]
See [Codex CLI](/integrations/codex) for setup. </Tab> [source]
For more tools, see [Integrations](/integrations). To connect an agent directly with an API key, see [Claude Code](/integrations/claude-code#connect-directly-to-ollama-cloud). [source]
- **Docker Users**: If Ollama is running on your host machine, use `http://host.docker.internal:11434` as the URL. - **Load Balancing**: You can add **multiple** Ollama instances. Open WebUI will distribute requests between them using a **random selection** strategy, providing basic load balancing for concurrent users. - **Note**: To enable this, ensure the **Model IDs match exactly** across instances. If you use **Prefix IDs**, they must be identical (or empty) for the models to merge into a single entry. [source]
- **`OLLAMA_CONTEXT_LENGTH`** is set on the **Ollama server** and is the default context length Ollama uses for a model. Since Ollama v0.15.5, Ollama picks this default from available VRAM: `4096` below 24 GiB, `32768` from 24 to 48 GiB, and `262144` at 48 GiB and above (see [Ollama's context length documentation](https://docs.ollama.com/context-length)). - **`num_ctx`** is an **Open WebUI advanced parameter** (Chat Controls > Advanced Parameters, or per model in the model editor). It is **unset by default**, so out of the box Ollama's `OLLAMA_CONTEXT_LENGTH` applies. [source]
> **num_ctx overrides OLLAMA_CONTEXT_LENGTH** > > If `num_ctx` is set anywhere in Open WebUI (a model preset's parameters or the chat's Advanced Parameters), Open WebUI sends it to Ollama on every request, and a per-request `num_ctx` **overrides** the server's `OLLAMA_CONTEXT_LENGTH`. Toggling the `num_ctx` control on **pre-fills it with `2048`**, which is very small, so it is easy to cap a model at 2048 tokens without realizing it, even after raising `OLLAMA_CONTEXT_LENGTH` on the Ollama side. [source]
- To set a default for all Ollama models, set `OLLAMA_CONTEXT_LENGTH` on the **Ollama server** and **leave `num_ctx` unset** in Open WebUI so it is not overridden. - To set it per model or per chat, set `num_ctx` to a realistic value for the model (for example `8192`, `16384` or the model's maximum), not the `2048` pre-fill. Remember it overrides `OLLAMA_CONTEXT_LENGTH`. - A larger context uses more VRAM and RAM, so size it to what your hardware can hold. [source]
export ANTHROPIC_AUTH_TOKEN=ollama export ANTHROPIC_API_KEY="" export ANTHROPIC_BASE_URL=http://localhost:11434 [source]
{ "mcpServers": { "websearch": { "type": "remote", "url": "${env://WEBSEARCH_URL:-https://api.example.com/mcp}", "headers": ["Authorization: Bearer ${env://WEBSEARCH_TOKEN}"] }, "weather": { "type": "remote", "url": "${env://WEATHER_URL:-https://weather-mcp.example.com}" } } } [source]
{ "mcpServers": { "websearch": { "transport": "streamable", "url": "https://api.example.com/mcp", "headers": ["Authorization: Bearer your-api-token"] } } } [source]
mcpServers: filesystem-local: type: "local" command: ["npx", "@modelcontextprotocol/server-filesystem", "/path/to/files"] environment: DEBUG: "true" filesystem-builtin: type: "builtin" name: "fs" options: allowed_directories: ["/tmp", "~/documents"] websearch: type: "remote" url: "https://api.example.com/mcp" [source]
export ANTHROPIC_BASE_URL=http://localhost:11434 export ANTHROPIC_API_KEY=ollama export ANTHROPIC_MODEL=qwen2.5-coder:1.5b [source]
curl https://ollama.com/api/web_search \ --header "Authorization: Bearer $OLLAMA_API_KEY" \ -d '{ "query":"what is ollama?" }' [source]
curl --request POST \ --url https://ollama.com/api/web_fetch \ --header "Authorization: Bearer $OLLAMA_API_KEY" \ --header 'Content-Type: application/json' \ --data '{ "url": "ollama.com" }' [source]
Tool calls: [ToolCall(function=Function(name='web_search', arguments={'max_results': 3, 'query': 'Ollama new engine'}))] Result: results=[WebSearchResult(content='# New model scheduling\n\n## September 23, 2025\n\nOllama now includes a significantly improved model scheduling system. Ahead of running a model, Ollama’s new engine [source]
chat_completion = client.chat.completions.create( messages=[ { 'role': 'user', 'content': 'Say this is a test', } ], model='gpt-oss:20b', ) print(chat_completion.choices[0].message.content) ``` [source]
const chatCompletion = await openai.chat.completions.create({ messages: [{ role: "user", content: "Say this is a test" }], model: "gpt-oss:20b", }); [source]
Arguments after `--` are passed directly to Cline: [source]
On macOS, open the [Ollama app](https://ollama.com/download) and select **Apps** in the sidebar. Connect Claude or ChatGPT. [source]
<div> <img alt="Create a n8n Credential" /> </div> [source]
<Note>Ollama web search for local models requires `ollama signin`.</Note> [source]
LangChainGo Ollama integration — For chain-based applications [source]
9 time out of 10, n8n does not manage the tool calling correctly [source]
def __init__( self, model: str, base_url: str = "http://localhost:11434", temperature: Optional[float] = None, context_window: int = -1, request_timeout: Optional[float] = DEFAULT_REQUEST_TIMEOUT, prompt_key: str = "prompt", json_mode: bool = False, additional_kwargs: Optional[Dict[str, Any]] = None, client: Optional[Client] = None, async_client: Optional[AsyncClient] = None, is_function_calling_model: bool = True, keep_alive: Optional[Union[float, str]] = None, thinking: Optional[Union[bool, Literal["low", "medium", "high"]]] = None, headers: Optional[Dict[str, str]] = None, **kwargs: Any, ) [source]
ollama launch Command Added in v0.15 [source]
const response = await fetch('http://localhost:11434/v1/messages', { method: 'POST', headers: { 'Content-Type': 'application/json', 'x-api-key': 'ollama' }, body: JSON.stringify({ model: 'qwen2.5-coder:1.5b', max_tokens: 100, messages: [{ role: 'user', content: 'Say hello in TypeScript' }], }), }); // → Response returned normally [source]
Ollama Blog: ollama launch [source]
```shell basic.sh theme={"system"} curl -X POST http://localhost:11434/v1/messages \ -H "Content-Type: application/json" \ -H "x-api-key: ollama" \ -H "anthropic-version: 2023-06-01" \ -d '{ "model": "qwen3-coder", "max_tokens": 1024, "messages": [{ "role": "user", "content": "Hello, how are you?" }] }' ``` </CodeGroup> [source]
Then run `ollama launch dsh`. On Windows, install Node.js for Windows. [source]
```shell basic.sh theme={"system"} curl -X POST http://localhost:11434/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-oss:20b", "messages": [{ "role": "user", "content": "Say this is a test" }] }' ``` </CodeGroup> [source]
1. In Intellij, click the **chat icon** located in the right sidebar [source]
<div> <img alt="Intellij Sidebar Chat" /> </div> [source]
<div> <img alt="Intellij model bottom right corner" /> </div> [source]
Website: https://ollama.com/ [source]
OpenCode requires a context length of 64k or higher. See Context length for more information. [source]
ollmcp mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer $YOUR_GITHUB_PAT" ollmcp mcp add --transport stdio playwright npx @playwright/mcp@latest ollmcp mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /allowed-dir1 ~/allowed-dir2 # stdio transport by default ollmcp mcp add --env API_KEY=YOUR_KEY --transport sse my-sse-server http://localhost:8000/sse [source]
ollmcp --host http://localhost:22545 --servers-json /path/to/servers.json [source]
ollmcp --mcp-server-url http://localhost:8000/sse --model qwen2.5:latest [source]
ollmcp --mcp-server-url http://localhost:8000/sse --mcp-server-url http://localhost:9000/mcp [source]
ollmcp --mcp-server /path/to/weather.py --mcp-server-url http://localhost:8000/mcp --model qwen3:1.7b [source]
ollmcp -s /path/to/weather.py -u http://localhost:8000/mcp -m qwen3:1.7b [source]
ollmcp --mcp-server /path/to/weather.py --mcp-server-url http://localhost:8000/mcp --claude-desktop [source]
ollmcp -s /path/to/weather.py -u http://localhost:8000/mcp --claude-desktop [source]
<Note>OpenClaw requires a larger context window. It is recommended to use a context window of at least 64k tokens if using local models. See [Context length](/context-length) for more information.</Note> [source]
Zed requests to Ollama include context length as the num_ctx parameter. By default, Zed uses 4096 tokens. [source]
n8n is very powerful and very flexible. As a result, you have to find a proper way to harness it. [source]
from llama_index.llms.ollama import Ollama [source]
Source code in llama-index-integrations/llms/llama-index-llms-ollama/llama_index/llms/ollama/base.py [source]
base_url: str = Field( default="http://localhost:11434", description="Base url the model is hosted under.", ) model: str = Field(description="The Ollama model to use.") temperature: Optional[float] = Field( default=None, description="The temperature to use for sampling.", ) context_window: int = Field( default=-1, description="The maximum number of context tokens for the model.", ) request_timeout: float = Field( default=DEFAULT_REQUEST_TIMEOUT, description="The timeout for making http request to Ollama API server", ) prompt_key: str = Field( default="prompt", description="The key to use for t [source]
The Ollama Python library provides the easiest way to integrate Python 3.8+ projects with Ollama. [source]
A custom client can be created by instantiating Client or AsyncClient from ollama. [source]
import asyncio from ollama import AsyncClient [source]
The Ollama Python library's API is designed around the Ollama REST API [source]
Available as ollama.systemone, Client.systemone, and await AsyncClient.systemone. Question and answer types, including SystemOneResponse, are exported from ollama. See the combined question example. [source]
Cloud + Local A reachable Ollama host, serving local models and (if signed in) :cloud models [source]
ollama pull gpt-oss:20b pip install -U langchain-ollama [source]
Continue may use a higher default context length than other tools. Reduce contextLength in your config (e.g., to 2048), or try a smaller model. See Ollama provider troubleshooting for details. [source]
Widen the API timeout — set HERMES_API_TIMEOUT=1800 in ~/.hermes/.env (see What You Need). [source]
Long context windows — cloud models offer 100K–1M tokens; local runtimes often default below Hermes' 64K minimum unless you configure them [source]
1. **Ollama API Key**: Set `OLLAMA_API_KEY` environment variable 2. **Cloud Models**: Use cloud models for optimal web search performance: - `qwen3-coder:480b-cloud` - Best for general web search - `gpt-oss:120b-cloud` - Best for complex reasoning with web data [source]
In environments that don’t use Docker Desktop (ie, Linux server installations), host.docker.internal is not automatically added.Run n8n in docker with --add-host=host.docker.internal:host-gatewayor add the following to a docker compose file: [source]
from llama_index.embeddings.ollama import OllamaEmbedding [source]
OpenCode uses the AI SDK and Models.dev to support 75+ LLM providers and it supports running local models. [source]
If tool calls aren’t working, try increasing num_ctx in Ollama. Start around 16k - 32k. [source]
The Ollama JavaScript library provides the easiest way to integrate your JavaScript project with Ollama. [source]
Available on the default client and new Ollama() from both ollama and ollama/browser. Both entry points export SystemOneRequest, SystemOneResponse, and the question/answer types. Browser requests follow the server's normal CORS rules. See the combined question example. [source]
host <string>: (Optional) The Ollama host address. Default: "http://127.0.0.1:11434". [source]
GitHub Copilot CLI is GitHub's AI coding agent for the terminal. It can understand your codebase, make edits, run commands, and help you build software faster. [source]
<div> <img alt="Adding a new Ollama model" /> </div> [source]
[OpenCode](https://opencode.ai) is an open-source coding agent that runs in your terminal, reads your project, edits files, and runs commands. [source]
<Note>OpenCode requires a context length of 64k or higher. See [Context length](/context-length) for more information.</Note> [source]
```javascript tools.js theme={"system"} import Anthropic from "@anthropic-ai/sdk"; [source]
The following example configures `qwen3-coder` for use with Droid. [source]
<Note> Ensure Apple Intelligence is setup and the latest XCode version is v26.0 </Note> [source]
1. Click **XCode** in top left corner > **Settings** [source]
<div> <img alt="Xcode Intelligence window" /> </div> [source]
<div> <img alt="Xcode settings" /> </div> [source]
n8n docs state Ollama does not support custom HTTP agents, so HTTP_PROXY/HTTPS_PROXY may not work for the n8n Ollama nodes. [source]
If only n8n is running in Docker, configure Ollama to listen on all interfaces by binding to `0.0.0.0` on the host. [source]
If both n8n and Ollama are running in Docker in separate containers, you can use Docker networking to connect them. [source]
Roo Code supports running models locally using Ollama. This provides privacy, offline access, and potentially lower costs, but requires more setup and a powerful computer. [source]
Token Tracking: Roo Code tracks token usage for models run via Ollama, helping you monitor consumption. [source]
> For the complete documentation index, see [llms.txt](https://docs.n8n.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.n8n.io/integrations/builtin/credentials/ollama.md). [source]
Documentation for the Ollama credentials. Use these credentials to authenticate Ollama in n8n, a workflow automation platform. [source]
If you're self-hosting n8n on the same machine as Ollama, you may run into issues if they're running in different containers. [source]
This connects to all servers registered via ollmcp mcp add and uses the model from your saved configuration file, or the first available model in Ollama if none is saved. Pass --claude-desktop to also include servers from Claude Desktop's config. [source]
New to working with AI and using self-hosted n8n? Try n8n's [self-hosted AI Starter Kit](/deploy/host-n8n/deploy-with-the-ai-starter-kit.md) to get started with a proof-of-concept or demo playground using Ollama, Qdrant, and PostgreSQL. [source]
How to Connect Ollama to External Workspaces via MCP [source]
github.com/ollama/ollama/api Official package inside the Ollama repo; used by the ollama CLI itself Full coverage mapped to REST; streaming supported Yes Considered the canonical Go client; API mirrors docs closely. [source]
Recommendation: For production, prefer github.com/ollama/ollama/api—it’s maintained with the core project and mirrors the REST API. [source]
go get github.com/ollama/ollama/api [source]
"github.com/ollama/ollama/api" ) [source]
For Go projects, github.com/ollama/ollama/api is the most complete, production-ready choice. It’s maintained alongside the Ollama core project, used by the official CLI, and provides comprehensive API coverage with guaranteed compatibility. [source]
Production application github.com/ollama/ollama/api Official support, complete API coverage, maintained with core project [source]
Open Cline settings > API Configuration and set API Provider to Ollama [source]
I started using n8n to learn it. I have a pretty good understand for working in it for 3 days and I just want to see if this is a me issue or if n8n just has very poor Ollama support. [source]
In the end, I just get the feeling n8n would not fit well into a production environment if you are using Ollama as an inference source. Is it me or is this what others feel as well? As a so-called “AI Workflow Engine” I feel the software is lacking in basic key features and stability. As it sits, I could never recommend this to any of the companies that I do business with due to these issues I ran into. [source]
N8n Chat (Beta) shows “Something went wrong” with Ollama provider, but the same Ollama model works in workflows (Docker on Windows) [source]
Home/Guides/n8n with Ollama: connect local AI models without the cloud [source]
20 July 2026 n8n with Ollama: connect local AI models without the cloud [source]
How do you set up the Ollama credentials in n8n? [source]
Frequently asked questions about n8n and Ollama [source]
Does Ollama have to run on the same server as n8n? [source]
No, Ollama can also run on a separate machine or server, as long as n8n can reach the base URL of that instance. In this case, enter the IP address or hostname of the Ollama server in the Ollama credential and secure the connection if needed via the optional API key. [source]
Does the Ollama Model Node work with the AI Agent Node? [source]
Does n8n also support proxy connections to Ollama? [source]
Only to a limited extent: Ollama itself does not support custom HTTP agents, so classic HTTP or HTTPS proxy configurations between n8n and Ollama can be problematic. For secured remote connections, bearer token authentication via the optional API key in the credential is the more reliable approach. [source]
AI Starter Kit: Ollama + Qdrant + n8n as a Docker Stack [source]
The Self-hosted AI Starter Kit from n8n starts n8n, Ollama, Qdrant and PostgreSQL via Docker Compose for local AI workflows without cloud APIs. [source]
Base URL and Docker networking are solved; after that the real work begins: model selection, response times and an operation that stays stable without cloud APIs. NordFlux takes n8n-Ollama setups from experiment to managed continuous operation, on your hardware or in our hosting. AI processing stays in-house without your team having to become Ollama administrators. [source]
Connect n8n with Ollama: use local AI models [source]
A CLI host application that enables Large Language Models (LLMs) to interact with external tools through the Model Context Protocol (MCP). Currently supports Claude, OpenAI, Google Gemini, and Ollama models. [source]
mcphost -m ollama/qwen2.5:3b -p "Explain quantum computing" --quiet [source]
mcphost -m ollama/qwen2.5:3b [source]
Chat and coding models Alibaba Model StudioAnthropicAnthropic Vertex plugin referenceArcee AIBasetenAmazon BedrockAmazon Bedrock MantleCerebrasChutesCohereDeepInfraDeepSeekFeatherless AIFireworksGitHub CopilotGMI CloudGoogle (Gemini)GroqHugging Face (inference)LongCatMetaMiniMaxMistralMoonshot AINovitaAINVIDIAOllama CloudOpenAI OpenAI OpenAI setupOpenAI authenticationOpenAI modelsOpenAI runtimes and Codex authOpenAI coverage and costOpenAI image generationOpenAI voice and speechAzure OpenAI endpointsOpenAI advanced configurationOpenCodeOpenCode GoPerplexityQianfanQwenRadiusStepFunSyntheticTeln [source]
Do not use the /v1 OpenAI-compatible URL (http://host:11434/v1). It breaks tool calling and models can emit raw tool-call JSON as plain text. Use the native URL: baseUrl: "http://host:11434" (no /v1). [source]
Ollama chat model integration. [source]
I tried running Claude Code locally with Ollama v0.15 [source]
If you have a genuine question about Ollama, local models, or Claude Code's actual capabilities, I am happy to help with accurate information. [source]
With Ollama v0.14.0 released on January 12, 2026, a /v1/messages endpoint compatible with the Anthropic API was added. By setting environment variables, Claude Code can connect to local Ollama. [source]
While integration with Claude Code is difficult, code generation with Ollama alone is sufficiently practical. [source]
Ollama v0.14.0's Anthropic API compatibility mode works technically, but reproducing the full functionality of Claude Code with local models is currently difficult. [source]
Ollama Blog: Claude Code with Anthropic API compatibility [source]
With your n8n instance, you’ll have access to over 400 integrations and a suite of basic and advanced AI nodes such as AI Agent, Text classifier, and Information Extractor nodes. To keep everything local, just remember to use the Ollama node for your language model and Qdrant as your vector store. [source]
In n8n, click Create Credential and select Ollama [source]
You can configure opencode to use local models through Ollama. [source]
1. **Install** — If Hermes isn't installed, Ollama prompts to install the Hermes command-line agent 2. **Model** — Pick a model from the selector (local or cloud). See currently-supported models [here](https://ollama.com/search). 3. **Onboarding** — Ollama configures the Ollama provider, points Hermes at `http://127.0.0.1:11434/v1`, and sets your model as the primary 4. **Gateway** — Optionally connects a messaging platform (Telegram, Discord, Slack, WhatsApp, Signal, Email) and launches the Hermes chat [source]
while True: response = chat( model='qwen3:4b', messages=messages, tools=[web_search, web_fetch], think=True ) if response.message.thinking: print('Thinking: ', response.message.thinking) if response.message.content: print('Content: ', response.message.content) messages.append(response.message) if response.message.tool_calls: print('Tool calls: ', response.message.tool_calls) for tool_call in response.message.tool_calls: function_to_call = available_tools.get(tool_call.function.name) if function_to_call: args = tool_call.function.arguments result = function_to_call(**args) print('Result: ', str [source]
Web search results can return thousands of tokens. It is recommended to increase the context length of the model to at least ~32000 tokens. Search agents work best with full context length. Ollama’s cloud models run at the full context length. [source]
{ "mcpServers": { "web_search_and_fetch": { "type": "stdio", "command": "uv", "args": ["run", "path/to/web-search-mcp.py"], "env": { "OLLAMA_API_KEY": "your_api_key_here" } } } } [source]
Ollama works well with OpenAI’s Codex tool. Add the following configuration to ~/.codex/config.toml [source]
[mcp_servers.web_search] command = "uv" args = ["run", "path/to/web-search-mcp.py"] env = { "OLLAMA_API_KEY" = "your_api_key_here" } [source]
<div> <img alt="Cline settings configuration showing API Provider set to Ollama" /> </div> [source]
Open models can be used with Copilot CLI through Ollama, enabling you to use models such as `qwen3.5`, `glm-5.3:cloud`, `kimi-k3:cloud` See all supported models [here](https://ollama.com/search). [source]
<div> <img alt="Add a first step with Ollama node" /> </div> [source]
1. Create an [API key](https://ollama.com/settings/keys) on **ollama.com**. 2. In n8n, click **Create Credential** and select **Ollama** 3. Set the **API URL** to `https://ollama.com` 4. Enter your **API Key** and click **Save** [source]
<Note>Ollama support in NemoClaw is still experimental.</Note> [source]
> **The problem this solves**: Standard Ollama providers can execute a tool and then return empty text. These wrapper functions synthesize a response so you get complete output. [source]
1. In Goose, open **Settings** → **Configure Provider**. [source]
<div> <img alt="Goose settings Panel" /> </div> [source]
<div> <img alt="Zed star icon in bottom right corner" /> </div> [source]
1. Login to your Onyx deployment (create an account first). [source]
<div> <img alt="Onyx Login Page" /> </div> [source]
<div> <img alt="Onyx Set Up Form" /> </div> [source]
1. In Zed, click the **star icon** in the bottom-right corner, then select **Configure**. [source]
"name": "Ollama (local)", [source]
export COPILOT_PROVIDER_BASE_URL=http://localhost:11434/v1 export COPILOT_PROVIDER_API_KEY= export COPILOT_PROVIDER_WIRE_API=responses export COPILOT_MODEL=qwen3.5 [source]
COPILOT_PROVIDER_BASE_URL=http://localhost:11434/v1 COPILOT_PROVIDER_API_KEY= COPILOT_PROVIDER_WIRE_API=responses COPILOT_MODEL=glm-5:cloud copilot [source]
Open WebUI makes it easy to connect and manage your **Ollama** instance. This guide will walk you through setting up the connection, managing models, and getting started. [source]
Once Open WebUI is installed and running, it will automatically attempt to connect to your Ollama instance. If everything goes smoothly, you’ll be ready to manage and use models right away. [source]
1. Go to **Settings > Admin > Connections** in Open WebUI. 2. Find your instance under **Manage Ollama API Connections** and click **Manage** (the download icon). From here, you can download models, configure settings, and manage your connection to Ollama. [source]
If you’re looking for a faster option to get started, you can download models directly from the **Model Selector**. Simply type the name of the model you want, and if it’s not already available, Open WebUI will prompt you to download it from Ollama. [source]
Ollama separates a model's thinking from its answer on its own. Since Ollama v0.9.0, models with thinking support (Qwen3, DeepSeek-R1, DeepSeek-V3.1, GPT-OSS) return the trace in a separate `thinking` field, and Open WebUI shows it in a collapsible section above the answer. No server-side flag is involved, and `ollama serve` takes none. [source]
That’s it! Once your connection is configured and your models are downloaded, you’re ready to start using Ollama with Open WebUI. Whether you’re exploring new models or running your existing ones, Open WebUI makes everything simple and efficient. [source]
Atomic Chat exposes an OpenAI-compatible server at http://127.0.0.1:1337/v1 by default [source]
curl http://localhost:11434/v1/chat/completions \ [source]
Base URL: http://localhost:11434/v1 [source]
base_url: "http://localhost:11434/v1" [source]
```shell streaming.sh theme={"system"} curl -X POST http://localhost:11434/v1/messages \ -H "Content-Type: application/json" \ -d '{ "model": "qwen3-coder", "max_tokens": 1024, "stream": true, "messages": [{ "role": "user", "content": "Count from 1 to 10" }] }' ``` </CodeGroup> [source]
```shell responses.sh theme={"system"} curl -X POST http://localhost:11434/v1/responses \ -H "Content-Type: application/json" \ -d '{ "model": "qwen3:8b", "input": "Write a short poem about the color blue" }' ``` </CodeGroup> [source]
<Note> To use **Ollama**, you will need a [JetBrains AI Subscription](https://www.jetbrains.com/ai-ides/buy/?section=personal\&billing=yearly). </Note> [source]
* [Visual Studio Code 1.127 or newer](https://code.visualstudio.com/download) * Ollama installed and running * At least one local or cloud model available in Ollama [source]
<Tab title="OpenAI Chat Completions"> ```shell theme={"system"} curl http://localhost:11434/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gemma4:e2b", "messages": [ { "role": "user", "content": "Say hello in one sentence." } ] }' ``` [source]
<Tab title="OpenAI Responses"> ```shell theme={"system"} curl http://localhost:11434/v1/responses \ -H "Content-Type: application/json" \ -d '{ "model": "gemma4:e2b", "input": "Say hello in one sentence." }' ``` [source]
<Tab title="Anthropic Messages"> ```shell theme={"system"} curl http://localhost:11434/v1/messages \ -H "Content-Type: application/json" \ -H "anthropic-version: 2023-06-01" \ -d '{ "model": "gemma4:e2b", "max_tokens": 1024, "messages": [ { "role": "user", "content": "Say hello in one sentence." } ] }' ``` [source]
Examples: `pip install llama-index-llms-ollama` [source]
_client: Optional[Client] = PrivateAttr() _async_client: Optional[AsyncClient] = PrivateAttr() [source]
@property def async_client(self) -> AsyncClient: if self._async_client is None: self._async_client = AsyncClient( host=self.base_url, timeout=self.request_timeout, headers=self.headers or {}, ) return self._async_client [source]
The AsyncClient class is used to make asynchronous requests. It can be configured with the same fields as the Client class. [source]
async def chat(): message = {'role': 'user', 'content': 'Why is the sky blue?'} response = await AsyncClient().chat(model='gemma4', messages=[message]) [source]
Trace LangChain applications (Python and JS/TS) [source]
model = ChatOllama( model="gpt-oss:20b", validate_model_on_init=True, temperature=0.8, num_predict=256, [source]
json_model = ChatOllama(format="json") json_model.invoke( "Return a query for the weather in a random location and time of day with two keys: location and time_of_day. " "Respond using JSON only." ).content [source]
from langchain_ollama import ChatOllama from pydantic import BaseModel, Field [source]
model = ChatOllama( model="deepseek-r1:8b", validate_model_on_init=True, reasoning=True, ) [source]
> Integrate with the ChatOllama chat model using LangChain Python. [source]
For detailed documentation of all features and configuration options, head to the [`ChatOllama`](https://reference.langchain.com/python/langchain-ollama/chat_models/ChatOllama) API reference. </Tip> [source]
`ChatOllama` supports token-level log probabilities via the `logprobs` and `top_logprobs` parameters. Log probabilities indicate how likely each token was at each generation step. [source]
For detailed documentation of all `ChatOllama` features and configuration options, see the [API reference](https://reference.langchain.com/python/langchain-ollama/chat_models/ChatOllama). [source]
The former Roo Code team began building Roomote, a new product. As of May 2026, Roomote is in early development with no public release. [source]
The most direct upgrade path from Roo Code. Kilo is actively maintained, open-source, and reads your existing .roomodes and .roo/rules/ config automatically on first startup — no rewrite needed. [source]
How Kilo compares to the new Roomote product. [source]
Answers to the most common questions from former Roo Code users. [source]
> For the complete documentation index, see [llms.txt](https://docs.n8n.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatollama/common-issues.md). [source]
The --yes flag auto-pulls the model, skips selectors, and requires --model to be specified. Arguments after -- are passed directly to Copilot CLI. [source]
Offline Use: Once you've downloaded a model, you can use Roo Code offline with that model. [source]
curl -fsSL https://opencode.ai/install | bash [source]
Tens of thousands of OpenClaw systems exposed by misconfigurations and known exploits [source]
A new report out today from security rating firm SecurityScorecard Inc. warns that widespread vulnerabilities in OpenClaw deployments have left tens of thousands of internet-facing instances exposed to takeover through misconfigured access controls and known exploits. [source]
While OpenClaw may be rapidly growing in popularity, according to SecurityScorecard’s STRIKE Threat Intelligence team, that growing adoption has been accompanied by systemic security weaknesses. [source]
The report highlights that many OpenClaw deployments are exposed by unsafe defaults and poor deployment hygiene. Out of the box, OpenClaw binds its control interface to all network interfaces, making it accessible from the public internet unless explicitly restricted. [source]
A large proportion of exposed instances were also found to be running outdated versions of the software, despite patches being available for several high-severity vulnerabilities. Only a minority of exposed systems were running the latest release of OpenClaw. [source]
OpenClaw instances were also found to be heavily concentrated within major cloud and hosting providers, suggesting insecure deployment patterns are being reused at scale. During the research period, the number of identified internet-facing instances continued to grow, ultimately exceeding 40,000 exposed deployments. [source]
🌐 Multi-Server Support: Connect to multiple MCP servers simultaneously [source]
📋 MCP Prompts Support: Browse, invoke, and manage prompts from MCP servers with argument collection, preview, and safe rollback [source]
📦 MCP Resources Support: Browse and read contextual data from MCP servers including files, documents, and structured data [source]
🗣️ Cross-Language Support: Seamlessly work with both Python and JavaScript MCP servers [source]
🔍 Auto-Discovery: Automatically find and use Claude's existing MCP server configurations [source]
🔄 Server Reloading: Hot-reload MCP servers during development without restarting the client [source]
Could not find a version that satisfies the requirement ollmcp (from versions: none) [source]
uv tool install --upgrade ollmcp # recommended, installs the CLI in an isolated environment [source]
On recent Debian/Ubuntu (Python 3.12+), the system pip is intentionally locked to protect OS-managed packages, so pip install ollmcp is blocked. This is a system policy (PEP 668), not an issue with ollmcp. Install it into an isolated environment instead: [source]
python3.11 -m venv ollmcp-env source ollmcp-env/bin/activate python3.11 -m pip install --upgrade ollmcp [source]
ollmcp mcp add --transport http <name> <url> ollmcp mcp add --transport sse <name> <url> [source]
Once you have added some servers, simply running ollmcp will connect to them automatically. [source]
local Current project only No ~/.config/ollmcp/mcp.local.json (keyed by project path) [source]
project Current project only Yes (via VCS) .mcp.json in the project root [source]
--mcp-server, -s: Path to one or more MCP server scripts (.py or .js). Can be specified multiple times. [source]
--mcp-server-url, -u: URL to one or more SSE or Streamable HTTP MCP servers. Can be specified multiple times. See Common MCP endpoint paths for typical endpoints. [source]
--claude-desktop: Load servers from Claude Desktop's config file (~/Library/Application Support/Claude/claude_desktop_config.json). Merged with servers added via ollmcp mcp add and any other flags. [source]
Whatever an MCP server reports is written to ~/.config/ollmcp/logs/<session>/<server>.log, one directory per run, keeping the last 5. Nothing a server prints reaches the screen unless you ask for it — otherwise it would draw over the answer being streamed. [source]
Servers report through two channels: their stderr (only stdio servers, since a remote one runs elsewhere) and MCP log notifications (any server). Both flags only change what you see on screen — the log file gets everything either way: [source]
ollmcp --mcp-server /path/to/weather.py --mcp-server /path/to/filesystem.js [source]
Calls the appropriate MCP server with these arguments (only if approved or HIL is disabled) [source]
MCP Prompts provide reusable, server-defined conversation starters and context templates. Servers can expose prompts with descriptions, required arguments, and pre-formatted messages that help you quickly start specific types of conversations or inject structured context into your chat. [source]
MCP Resources provide access to contextual data exposed by MCP servers-files, documents, structured data, and more. Servers can expose resources with metadata (name, description, MIME type) that you can browse and read into your conversation context. [source]
The /reload-servers command (/rs) is particularly useful during MCP server development. It allows you to reload all connected servers without restarting the entire client application. [source]
Reconnect using the same parameters (servers added via ollmcp mcp add, server paths, config files, --claude-desktop) [source]
Exports your current chat history to a JSON file. You can specify a custom filename or use the default timestamp-based name (e.g., ollmcp_chat_history_2026-01-05_143022.json). Files are saved to ~/.config/ollmcp/history/ directory. The command includes file overwrite protection. [source]
Type / after the prompt symbol to see autocomplete suggestions for available MCP prompts. [source]
Running ollmcp with no flags automatically loads the default configuration from ~/.config/ollmcp/config.json if it exists. [source]
The JSON configuration file supports STDIO, SSE, and Streamable HTTP server types (MCP 1.10.1): [source]
MCP 1.10.1 Transport Support: The client now supports the latest Streamable HTTP transport with improved performance and reliability. If you specify a URL without a type, the client will default to using Streamable HTTP transport. [source]
A common point of confusion is where to store MCP server configuration files and how the TUI's save/load feature is used. Here's a short, practical guide that has helped other users: [source]
The TUI's /save-config / /load-config (or /sc / /lc) commands are intended to save TUI preferences like which tools you enabled, your selected model, thinking mode, display mode, and other client-side settings. They are not required to register MCP server connections with the client. [source]
You can then point ollmcp at that file at startup with -j / --servers-json. [source]
For HTTP-based MCP servers, "type": "http", "streamable-http", and "streamable_http" are all accepted and treated the same way. Also check the Common MCP endpoint paths section below for typical endpoints. [source]
{ "mcpServers": { "github": { "type": "streamable_http", "url": "https://api.githubcopilot.com/mcp/", "headers": { "Authorization": "Bearer mytoken" } } } } [source]
A short demo (asciicast) that should help anyone reproduce the working setup quickly. This example uses an MCP server example with streamable HTTP protocol usage: [source]
Streamable HTTP MCP servers typically expose the MCP endpoint at /mcp (e.g., https://host/mcp), while SSE servers commonly use /sse (e.g., https://host/sse). Below is an excerpt from the MCP specification (2025-06-18): [source]
The server MUST provide a single HTTP endpoint path (hereafter referred to as the MCP endpoint) that supports both POST and GET methods. For example, this could be a URL like https://example.com/mcp. [source]
You can find more details in the MCP specification version 2025-06-18 - Transports. [source]
You can explore a collection of MCP servers in the official MCP Servers repository. [source]
MCP Server with Streamable HTTP Example - An example MCP server demonstrating the usage of the streamable HTTP protocol. [source]
MCP servers you connect are trusted by you, and their tool/resource responses are treated as untrusted content that reaches the model. See SECURITY.md for the trust model, how indirect prompt injection is handled, and how to report a vulnerability. [source]
codex --oss -m gpt-oss:120b [source]
codex --oss -m gpt-oss:120b-cloud [source]
client, err := api.ClientFromEnvironment() if err != nil { return nil, fmt.Errorf("creating client: %w", err) } [source]
Recommended Cline Settings for Local Inference [source]
In Cline Settings, select the matching provider [source]
I have been having, what I would consider, massive stability issues with n8n. [source]
I have no idea why you would think the hammer analogy would apply to my post. Admittedly, I’m new to n8n but I do not think I’m miss-using the nodes or some how doing something outside the norm of what n8n should be able to do. Are you saying I’m using n8n in a way it wasn’t ment to be used? [source]
Claude Code prompts for permission on most actions. To allow the bot to work autonomously, configure permission rules or pass --dangerously-skip-permissions in an isolated environment. See the plugin README for setup instructions. [source]
A CLI host application that enables Large Language Models (LLMs) to interact with external tools through the Model Context Protocol (MCP). [source]
MCPHost maintains full backward compatibility with the previous configuration format. Note: A recent bug fix improved legacy stdio transport reliability for external MCP servers (Docker, NPX, etc.). [source]
#!/usr/bin/env -S mcphost script --- mcpServers: github: type: "local" command: ["gh", "api"] environment: GITHUB_TOKEN: "${env://GITHUB_TOKEN}" DEBUG: "${env://DEBUG:-false}" [source]
MCPHost's non-interactive mode makes it perfect for automation, scripting, and integration with other tools. [source]
MCPHost can work with any MCP-compliant server. For examples and reference implementations, see the MCP Servers Repository. [source]
You configure your model provider by setting environment variables before starting Copilot CLI. [source]
COPILOT_PROVIDER_MODEL_IDThe well-known model name. Copilot CLI uses this value to identify model capabilities and token limits. [source]
You can run Copilot CLI in offline mode to prevent it from contacting GitHub's servers. This is designed for isolated environments where the CLI should communicate only with your local or on-premises model provider. [source]
Running code and approvals apply_patch toolCode executionDiffsElevated modeExec toolExec approvalsExec approvals — advancedPermission modesSecrets Media and documents Media overviewImage generationMusic generationPDF toolText-to-speech Text to speech Text-to-speech quickstartText-to-speech configurationText-to-speech personasText-to-speech commands and directivesText-to-speech output and Auto-TTS behaviorText-to-speech field referenceText-to-speech agent tool and Gateway RPCVideo generation Tool catalogs and workflows Code Mode Code Mode Code Mode quickstartCode Mode executorsCode Mode configu [source]
The Roo Code Extension was shut down on May 15th. [source]
No file was actually created; only the JSON of the tool call was displayed. Moreover, "TodoWrite" is a task management tool in Claude Code and is not used for code generation. Small models "recognize" Claude Code's tool definitions but are unable to select and execute the correct tool. [source]
Claude Code runs locally ⚠️ Can connect, but doesn't work properly [source]
Infosecurity Magazine Home » News » Researchers Find 40,000+ Exposed OpenClaw Instances [source]
The exposed AI agents could enable threat actors to gain full access to potentially sensitive systems the OpenClaw instance is able to interact with. [source]
Vulnerability exploitation appears likely. SecurityScorecard has already discovered three high-severity CVEs in OpenClaw, with public exploit code available for each. [source]
Some OpenClaw users have also been leaking API keys linked to third-party services via their control panels, further amplifying the impact of instances’ internet exposure. [source]
🔗 **[MCP Tools Example](../../examples/node/src/mcp-tools-example.ts)** - Model Context Protocol integration [source]
You can configure opencode to use local models through llama.cpp’s llama-server utility [source]
You can configure opencode to use local models through LM Studio. [source]
You can enable web search in any MCP client through the Python MCP server. [source]
* Use Codex from a terminal with [Codex CLI](/integrations/codex). * Connect other desktop apps from [Claude Desktop](/integrations/claude-desktop). [source]
[Claude Code](https://code.claude.com/docs/en/overview) reads your codebase, edits files, and runs commands. [source]
Connect a Telegram bot to your Claude Code session. Install the [Telegram plugin](https://github.com/anthropics/claude-plugins-official), create a bot with [@BotFather](https://t.me/BotFather), then launch Claude Code: [source]
Claude Code prompts for permission on most actions. To allow the bot to work autonomously, configure [permission rules](https://code.claude.com/docs/en/permissions) or pass `--dangerously-skip-permissions` in an isolated environment. [source]
<p>1. Install Claude Code</p> [source]
<p>3. Run Claude Code</p> [source]
<CodeGroup> ```shell macOS / Linux (Homebrew) theme={"system"} brew install copilot-cli ``` [source]
The `--yes` flag auto-pulls the model, skips selectors, and requires `--model` to be specified. Arguments after `--` are passed directly to Copilot CLI. [source]
* Creating custom Agents * Web search * Deep Research * RAG over uploaded documents and connected apps * Connectors to applications like Google Drive, Email, Slack, etc. * MCP and OpenAPI Actions support * Image generation * User/Groups management, RBAC, SSO, etc. [source]
<p>1. Install OpenCode</p> [source]
<CodeGroup> ```shell macOS / Linux theme={"system"} curl -fsSL https://opencode.ai/install | bash ``` [source]

Related concepts

ollama — is a related of Ollama integrations and ecosystem
MCP — is a instance of Ollama integrations and ecosystem
localhost — is a problem of Ollama integrations and ecosystem
n8n — is a instance of Ollama integrations and ecosystem
ollama launch — is a synonym of Ollama integrations and ecosystem
Claude Code — is a instance of Ollama integrations and ecosystem
openai compatibility — is a dependent of Ollama integrations and ecosystem
Codex — is a instance of Ollama integrations and ecosystem
tool calling — is a dependent of Ollama integrations and ecosystem
num_ctx — is a problem of Ollama integrations and ecosystem
OpenClaw — is a instance of Ollama integrations and ecosystem
OpenCode — is a instance of Ollama integrations and ecosystem
coding agent — is a hypernym of Ollama integrations and ecosystem
Cline — is a instance of Ollama integrations and ecosystem
Roo Code — is a instance of Ollama integrations and ecosystem
ollama signin — is a part of Ollama integrations and ecosystem
OLLAMA_HOST — is a part of Ollama integrations and ecosystem
Copilot CLI — is a instance of Ollama integrations and ecosystem
LangChain — is a instance of Ollama integrations and ecosystem
Hermes — is a instance of Ollama integrations and ecosystem

Children

Agent harnesses on Ollama: OpenClaw / Hermes Agent / Goose / Pi
Claude Code env-var tier remapping for local model names (frontier)
Codex custom model providers and profiles (frontier)
Community Go and other-language Ollama clients (frontier)
Context length sizing for tool-heavy agents (frontier)
Continue autocomplete model choice (frontier)
Copilot CLI BYOK offline mode (frontier)
Editor integrations for Ollama: Continue / Cline / Roo Code / Zed / JetBrains / VS Code
Embeddings Ollama node and RAG workflows (frontier)
Goose tool shim (frontier)
Hermes Desktop on Ollama (frontier)
Kilo Code with Ollama (frontier)
Kit (MCPHost successor) (frontier)
LangChain OllamaEmbeddings and RAG pipelines (frontier)
LangChain and LlamaIndex integrations with Ollama
LlamaIndex agents with Ollama function calling (frontier)
Ollama MCP: MCP clients and servers on local models
Ollama client libraries: ollama-python / ollama-js / Go api package
Ollama cloud API access and OLLAMA_API_KEY (frontier)
Ollama web search MCP server (frontier)
Ollama web search and fetch API (frontier)
OpenClaw gateway security hardening (frontier)
Pi extension ecosystem for Ollama Cloud (frontier)
Zed Edit Prediction with Ollama (frontier)
Zoo Code fork (frontier)
n8n AI Agent tool calling with local models (frontier)
n8n Docker networking for Ollama (frontier)
n8n and workflow automation with Ollama
ollama launch and coding-agent integrations: Claude Code / Codex / OpenCode / Copilot CLI
ollama launch config files under ~/.ollama/launch (frontier)

Frontier under this node: Claude Code env-var tier remapping for local model names, Codex custom model providers and profiles, Community Go and other-language Ollama clients, Context length sizing for tool-heavy agents, Continue autocomplete model choice, Copilot CLI BYOK offline mode, Embeddings Ollama node and RAG workflows, Goose tool shim, Hermes Desktop on Ollama, Kilo Code with Ollama, Kit (MCPHost successor), LangChain OllamaEmbeddings and RAG pipelines, LlamaIndex agents with Ollama function calling, Ollama cloud API access and OLLAMA_API_KEY, Ollama web search MCP server, Ollama web search and fetch API, OpenClaw gateway security hardening, Pi extension ecosystem for Ollama Cloud, Zed Edit Prediction with Ollama, Zoo Code fork, n8n AI Agent tool calling with local models, n8n Docker networking for Ollama, ollama launch config files under ~/.ollama/launch

← the whole tree · 3D view· how to read this page