--- title: "OpenCode with Ollama: Fix Connection and Tool Failures" description: "Diagnose OpenCode and Ollama failures with endpoint checks, exact model IDs, context verification, and a small coding fixture." date: 2026-10-28 location: "San Francisco, CA - Oct 28th, 2026" image: /images/opencode-ollama-troubleshooting-hero.jpg unlisted: true keywords: "opencode ollama troubleshooting, opencode ollama not working, ollama opencode tool calling, opencode local model connection" tags: - OpenCode - Ollama - Troubleshooting author: name: "Wayne Pan" url: "https://www.linkedin.com/in/wapan/" title: "CTO" faq: - question: "Does a successful Ollama chat mean OpenCode tools will work?" answer: "No. A chat response proves the model can generate text. OpenCode also needs structured tool calls, permission to execute them, and enough context for the task. Verify an actual file edit and its test result." - question: "Does increasing OpenCode's context limit allocate more Ollama memory?" answer: "An advertised context limit in OpenCode does not prove Ollama allocated that context. Configure the Ollama server and inspect the running model with ollama ps. Larger context also increases memory requirements." - question: "Should I reinstall everything when an Ollama model disappears from OpenCode?" answer: "Start by comparing the model IDs returned by Ollama with the model declared in your OpenCode configuration. Check the endpoint and selected provider before reinstalling either application." --- When **OpenCode with Ollama stops working**, check the server endpoint and exact model ID before changing models. If both checks pass, test a small file edit to separate a tool-call problem from a connection problem. A model that answers a chat request has only passed the first part of a coding-agent workflow. This guide assumes Ollama and OpenCode are installed. For installation and provider setup, use the [Ollama with OpenCode setup guide](/blog/ollama-opencode-setup/). The procedure here isolates failures without repeatedly changing your working configuration. ## Find which request is failing An OpenCode failure can happen before inference, during generation, or when a tool executes. Check those stages separately. A refused connection identifies a different problem from a model returning a JSON-looking paragraph. Record the endpoint, selected model, and error before changing a setting so you can tell whether the change helped. | Observation | Next check | What the result establishes | |---|---|---| | Connection refused | Request `/api/version` on the configured host and port | Whether that Ollama endpoint is reachable | | Model not found | Read `/v1/models` and compare the exact ID | Whether the requested model exists on that server | | Chat works, files stay unchanged | Inspect tool calls and permission results | Whether OpenCode attempted and completed an action | | Small edits work, large tasks fail | Inspect allocated context and runtime logs | Whether the larger task encounters a measurable limit | | Local works, cloud hangs | Test the two routes separately | Whether the failure is specific to the cloud path | Record versions before reproducing a failure: ```bash opencode --version ollama --version ``` The local checks for this article used OpenCode 1.19.4 and Ollama 0.32.9 on an Apple M3 Ultra with 96 GB of unified memory. That hardware can run our chosen 31B model; it is not a memory recommendation for a smaller laptop. For model selection on other hardware, read the [Ollama coding-model guide](/blog/best-ollama-models-for-coding-agents/). ## Check the endpoint before changing the model Request the same host and port that OpenCode uses. A local server at `127.0.0.1:11434` and a server at `127.0.0.1:11435` are different endpoints. If the request fails, repair the server or address first. Changing the model cannot repair a refused network connection. ```bash curl --fail-with-body --max-time 5 \ http://127.0.0.1:11434/api/version curl --fail-with-body --max-time 5 \ http://127.0.0.1:11434/v1/models ``` A version response confirms that Ollama answered. A model-list response confirms which model IDs that server exposes. An empty list means the server is reachable but has no listed models; it is different from a connection error. If Ollama is stopped, start the application or run its server in a terminal: ```bash ollama serve ``` If the port is already occupied, check which server is running rather than starting another copy. A remote Ollama installation requires its remote address; `127.0.0.1` always refers to the machine running the client. [Ollama's OpenCode integration documentation](https://docs.ollama.com/integrations/opencode) uses an OpenAI-compatible base URL ending in `/v1`. Keep that suffix in OpenCode's provider configuration. Native diagnostic routes such as `/api/version` sit outside it. ## Match the configured model to the server's exact ID Use the model ID returned by the server, including its tag. A model downloaded on one Ollama server is unavailable to another unless it has the same model. Check the selected provider, its base URL, and the model declaration together before retrying the request. This is the provider shape used for our OpenCode 1.19.4 checks: ```json { "provider": { "ollama": { "npm": "@ai-sdk/openai-compatible", "options": { "baseURL": "http://127.0.0.1:11434/v1" }, "models": { "gemma4:31b": { "name": "Gemma 4 31B", "limit": { "context": 65536, "output": 2048 } } } } } } ``` Replace `gemma4:31b` with an ID your server actually lists. The example does not download that model. OpenCode's full selector combines the provider name and model ID: ```bash opencode run -m ollama/gemma4:31b "Reply with one short sentence." ``` We deliberately requested an absent model through Ollama's compatible endpoint and received HTTP 404 with a `not_found_error`. That result establishes a model-selection error. It does not indicate a memory shortage or a broken tool parser. Configurations can also come from several locations. [OpenCode's configuration documentation](https://opencode.ai/docs/config/) describes how settings merge. Inspect the resolved configuration locally when a value seems ignored: ```bash opencode debug config ``` Resolved configuration can contain credentials. Extract the relevant provider settings before sharing a diagnostic report, and remove keys or unrelated account details. ## Verify an action with a disposable coding fixture Check the changed file and run its test yourself. Give OpenCode a tiny file with one known bug, ask it to repair the file, and run an independent check afterward. This tests file access, editing, and execution while keeping the diagnosis small enough to inspect. Create a fresh directory and enter it: ```bash mkdir opencode-ollama-check cd opencode-ollama-check cat > add.mjs <<'JS' export function add(a, b) { return a - b; } JS cat > check.mjs <<'JS' import { add } from './add.mjs'; if (add(2, 3) !== 5) throw new Error('Expected add(2, 3) to return 5'); console.log('PASS'); JS node check.mjs ``` The first check should fail. Copy your tested provider configuration into this disposable directory, then run: ```bash opencode run -m ollama/gemma4:31b \ "Read add.mjs. Fix add so it adds its arguments. Run node check.mjs." node check.mjs ``` Inspect `add.mjs` yourself. A success message from the model is insufficient if the file still subtracts or the independent check fails. Keep permission prompts visible so you can distinguish a denied edit from a missing tool call. During our checks, macOS resolved the fixture under `/private/tmp` while a tool requested its `/tmp` alias. OpenCode treated the aliased path as external and rejected it in a noninteractive run. Using the resolved directory and relative file paths let the fixture run with narrowly scoped permissions. For deeper inspection, [OpenCode's CLI](https://opencode.ai/docs/cli/) supports JSON output: ```bash opencode run --format json -m ollama/gemma4:31b \ "Read add.mjs and explain the implementation." ``` Look for an executed tool and its result. Text containing a function name or a JSON object does not by itself establish that OpenCode executed anything. After correcting the endpoint and fixture permissions, one repair run read the fixture, changed subtraction to addition, and passed an independent Node check. A second run passed the same check after replacing the deliberately absent model ID. In our separate direct-API probe, Gemma 4 31B returned a structured `read_file` call at 65,536 context. That single result validates the probe's response format, not reliability across coding tasks. ## Check the context Ollama actually allocated OpenCode's advertised model limit and Ollama's runtime allocation need to agree. Increasing a number in the client configuration does not demonstrate that the server allocated more context. Inspect the running model during a request, then compare its actual context with the task's prompt and tool history. [Ollama's context documentation](https://docs.ollama.com/context-length) recommends at least 64,000 tokens for coding tools and agents. It also explains that larger allocations consume more memory. A server launched manually can set an explicit allocation: ```bash OLLAMA_CONTEXT_LENGTH=65536 ollama serve ``` Set that variable on the process running Ollama. Exporting it only in the terminal running OpenCode does not reconfigure an already-running Ollama application. Use the application's context setting if the application manages your server. While the model is loaded, inspect it: ```bash ollama ps ``` Check the `CONTEXT` and `PROCESSOR` columns. If Ollama uses a custom host or port, point the CLI at that server too. Memory pressure, CPU offloading, truncation, and tool-format failures need separate evidence; a slow response alone cannot identify which occurred. If your hardware cannot accommodate the required context, choose a smaller model that supports tools and repeat the same fixture. Avoid comparing two models using different tasks and then attributing the difference to model quality. ## Keep a useful failure report A useful report lets another developer reproduce the same request. Include the versions, sanitized provider configuration, exact model tag, allocated context, and the smallest fixture that still fails. Record whether a direct request succeeds and whether OpenCode reaches the model server. Those details help maintainers locate the failure. The [OpenCode troubleshooting guide](https://opencode.ai/docs/troubleshooting/) explains how to locate logs. On the tested version, this command identifies the configured data and log paths: ```bash opencode debug paths ``` Keep local and cloud results separate. A local coding test cannot validate Ollama Cloud authentication or availability, and a cloud outage does not establish a local tool-use regression. Likewise, an older issue describing the same symptom does not prove that its proposed fix applies to your installed version. If the fixture succeeds but your repository task fails, preserve the working fixture and add complexity gradually: another file, a larger input, or a longer tool sequence. The first change that reproduces the failure is more useful than reinstalling both applications without a comparison. For a separate provider configuration after you finish the local diagnosis, the [OpenCode custom-provider guide](/blog/opencode-custom-provider-setup/) covers Haimaker setup. Keep private local tests local; switching providers is an optional next step when the workload allows it. ## Frequently asked questions #### Does a successful Ollama chat mean OpenCode tools will work? No. A chat response proves the model can generate text. OpenCode also needs structured tool calls, permission to execute them, and enough context for the task. Verify an actual file edit and its test result. #### Does increasing OpenCode's context limit allocate more Ollama memory? An advertised context limit in OpenCode does not prove Ollama allocated that context. Configure the Ollama server and inspect the running model with ollama ps. Larger context also increases memory requirements. #### Should I reinstall everything when an Ollama model disappears from OpenCode? Start by comparing the model IDs returned by Ollama with the model declared in your OpenCode configuration. Check the endpoint and selected provider before reinstalling either application.