On this page8 sections
The manuscript is unfinished, the notes are private, and the writer would rather keep both on the laptop. A downloaded AI model seems a good fit. Then comes a reasonable request: look up a historical date, and read a few scanned pages. The model has not moved. Parts of the job may have.
In this illustrative workflow, local inference means the model can calculate its answer on the chosen computer. It does not promise that every feature around the model stays there. Document preparation, search tools and saved conversations each have their own route. An engineering team searching internal service manuals has the same question when its chat model runs on a company server but another service extracts the uploaded text.
That is useful control worth understanding, not a reason to dismiss local AI. Follow the manuscript through the job and you can choose which connections to keep. These examples are teaching situations, not tested installations or demonstrated leaks.
The paragraph can stay on the laptop
Start with one paragraph already on the machine. Software called a runtime loads the model’s learned numerical values, its weights, and uses them to calculate a response. That calculation is inference. With the runtime and model on the laptop, the paragraph can be processed there rather than sent to a hosted model service. The model inference guide follows that calculation in more detail.
For this simple writing task, a downloaded model and an app that handles the conversation locally may be enough. LM Studio’s offline documentation describes chat, document processing and local serving without an internet connection once the model is available. Finding and downloading models, obtaining runtimes and checking application updates are separate network activities. An app can need a connection to acquire its model without needing one to answer the paragraph question.
The word “local” also covers more than one arrangement. A desktop app may send the paragraph to another program on the same computer, or a team’s app may send it to a company-controlled server. The additional step matters even when neither uses a hosted model provider.
Which part is local in this setup?
| Arrangement | Where the model runs | Other parts of the route |
|---|---|---|
| Downloaded model inside a desktop app | Your computer | Document processing, plugins, history and background connections |
| Desktop app using a separate local runtime | Your computer, through a separate service | The app, the runtime and each selected provider |
| Team app using a self-hosted model | An organization-controlled server | Travel to the server, connected services and access by administrators |
| Deployment with restricted network access | Inside an environment with restricted connections | Processes covered by the restriction, file transfers and retained copies |
Suppose the app points to an Ollama server on the laptop. Its address tells you the first stop. Ollama’s API documentation also describes using cloud models through that local server after sign-in. So localhost, an address for this computer, does not settle the final destination. The selected model and provider tell the rest of that part of the story.
The writer can now name a setup rather than a label: this app, this model, this runtime and these document features. The engineering team adds the company server and the services it calls. Those are the places the material might meet.
The scanned page has a journey before the answer
Now attach the scanned notes. The scan is a picture; the application may first need to recover its words. That step is optical character recognition, or OCR. If the chosen OCR service is remote, the page can leave the laptop before the writer asks a question. Local text extraction and retrieval can keep that document path on the computer instead. Convenience, supported languages and recognition quality may differ too.
A long document may need more preparation. An app can extract its text, split it into passages and find the portions relevant to the question. An embedding model can turn those passages into lists of numbers that help compare related meaning, as Ollama’s embeddings documentation explains. The selected passages then travel with the question to the answering model. This arrangement is retrieval-augmented generation, usually shortened to RAG.
Each step runs somewhere. A hosted extractor can prepare words for a local answering model. An outside embedding service receives the text it represents. Putting the last calculation on the laptop does not, by itself, move the preparation there.
Voice notes pose the same question one step earlier: where does the sound become text? Family records, work PDFs and internal manuals all deserve that look at preparation. The Open WebUI offline guide covers dependencies for local operation, including document and speech processing. It is a community-contributed guide on the official site, so read it alongside the configuration documentation for the installed release.
Include extraction, embeddings and storage when you describe the setup, not just the model that writes the answer. This helps when something breaks as well: a document upload can fail at preparation while ordinary local chat still works.
Looking up a date does not require sending the chapter
The writer needs a public historical date. A local model can request a web search, just as it can request a file read or an action in another app. The surrounding software decides whether to run that request, supplies the required access and returns the result. Ollama’s tool-calling guide separates the model’s request from that execution.
The date question can be sent without the unpublished chapter. A search tool can accept only what the lookup needs. Inspecting the request the app actually makes distinguishes that narrow question from a request carrying extra manuscript text.
Some apps connect these tools through the Model Context Protocol, or MCP. A program called an MCP server provides tools or information to the app; it may run on the laptop or remotely. The protocol’s architecture documentation distinguishes those locations. But a search program running beside the model can still go out to the internet for the date. The program’s location and the information’s source are different things.
LM Studio documents MCP hosting from version 0.3.17, with local and remote servers supported from 0.3.17 build 10. Its MCP guidance warns that servers can have access to files, code execution and the network. Before adding one, look at what that particular server can do in the installed release. The model may be unchanged while the app gains substantial new access.
Even the browser used for the lookup matters. One signed in to private accounts brings a different session from one reading only public pages. For the engineering team, a deployment-status tool might need only a service name to return a version and timestamp. A terminal with access to an entire home directory is much broader. Match filesystem access, credentials and network restrictions to the requested job.
A read-only manuscript folder prevents some changes, not reading. A tool could still read text and pass it to another service. Keep secrets and unrelated documents outside the tool’s accessible scope rather than relying only on an instruction to ignore them. The MCP security guidance recommends limiting local-server privileges and access.
There is also a difference between reading a web page and obeying it. A returned page may contain instructions meant to redirect the assistant, the indirect prompt-injection problem described by OWASP. The writer asked for a date; the page has not acquired authority over the manuscript. Local calculation does not make the page trustworthy. Enforced tool boundaries remain useful even when the model usually handles outside material correctly.
A connection is a question, not yet an answer
Suppose a network connection appears while the app is open. It could be the requested search, a model-catalog lookup, an update check or a crash report. The connection alone does not establish that the manuscript went with it. Find the activity, the component responsible and what the request carried.
LM Studio’s distinction between local conversation processing and connected discovery, runtime downloads and update checks is useful here. It lets you ask about a particular exchange rather than trying to classify every connection as either harmless or a leak.
Reporting controls have boundaries of their own. In VS Code, telemetry.telemetryLevel set to off stops the editor’s own telemetry going forward. Extensions can collect data separately, and other online features have separate controls. A local-model extension does not automatically inherit every choice made in the editor. The VS Code telemetry documentation explains that scope.
You may choose to turn off reporting you do not need. Leaving all updates off indefinitely is a different decision: the software still needs fixes. An isolated team service can arrange controlled updates; an individual can reconnect deliberately for downloads. The useful choice is which exchanges you want, not a hope that the word “local” has already decided.
The answer is finished. The folder may still be syncing.
After the chat, imagine the writer saves it in a cloud-synchronized folder. Another application now copies it elsewhere. The model processed the conversation locally, but its location has no say over what the folder does next.
History, uploaded files, retrieval indexes, logs and backups can keep different pieces of the task for different lengths of time. Deleting the chat does not necessarily remove an exported file or a separately retained backup.
On a shared service, someone must also decide who can open the data directory, which logs are collected centrally and where backups live and expire. Open WebUI’s storage guidance identifies its data directory as holding the database, uploads and cached plugins, and calls for suitable filesystem permissions and backup handling.
Encryption and access controls can protect these copies when they match the people and processes allowed to use them. Self-hosting puts those decisions in the operator’s hands. It does not remove the need to make them.
Choose the connection you mean to change
The writer may want a wholly local manuscript assistant, or a local assistant with permission to research public facts. Both are specific choices. In the first case, hosted document preparation or tools would leave part of the job outside. In the second, the search can remain while unnecessary manuscript text stays out of its requests.
For Ollama, the documented cloud-disable choices are OLLAMA_NO_CLOUD=1 or disable_ollama_cloud: true in ~/.ollama/server.json. The FAQ calls for a restart and the log confirmation Ollama cloud disabled: true. Match the instructions to the installed version. That confirmation concerns Ollama’s cloud features, not every other application handling the manuscript.
For Open WebUI, OFFLINE_MODE=true suppresses selected automatic network activity. It does not block configured external model APIs, search, tool servers or storage. A setup that must be network-isolated needs separately enforced restrictions; the offline-mode guidance makes that distinction explicit.
There is a second wrinkle when checking the setting. The configuration reference, identified as v0.12.1 in the original October 28 review, distinguishes ordinary environment variables from database-persisted ConfigVar settings. Those saved settings may keep their active value after the first launch even if a startup variable changes. Look at the current application setting, not just yesterday’s deployment file, to understand today’s document route.
For LM Studio, return to the enabled MCP servers and identify the one that answered the date question. Its added access is separate from the documented local chat and document features. A downloaded model does not relocate a remote tool.
Check the selected provider and any documented fallback too. Some applications may use a hosted service when local capacity is unavailable. The answer could arrive by a different route, deliberately or unexpectedly. That behavior is not universal, and one similarly named switch does not disable it across every product.
Finally, know what you are installing before handing it private notes. The model’s numerical weights, its runtime and any custom modeling code are different things to trust. The Hugging Face model-loading guide describes extra care with custom code, pinning a specific revision and preferring the safer safetensors weight format when available. A familiar model name is not a review of all the code that accompanies it.
Try the route with a page you can afford to share
Before opening the manuscript, identify the application and runtime versions, selected model and provider, document processors, enabled tools and saved-conversation location. For a team service, include the backend configuration: a browser settings screen may describe only the part in front of you.
If Ollama is already running on its default local port, these optional read-only requests ask for its version and loaded models. They require curl and a Bash-compatible shell; they do not start a server:
curl -q --noproxy '*' --fail --silent --show-error --max-time 5 http://127.0.0.1:11434/api/version
curl -q --noproxy '*' --fail --silent --show-error --max-time 5 http://127.0.0.1:11434/api/ps
Neither request submits a prompt, downloads a model or changes a setting. The Ollama API reference and running-models reference document the endpoints. In the curl manual, -q avoids the default curl configuration; the proxy option keeps these requests direct, and the timeout limits the wait. The answer describes this runtime, not every program in the workflow.
Use a synthetic document with a recognizable sentence: “The practice maintenance window starts at 09:15.” Attach it, ask about it and export the answer. If voice or search belongs in the intended workflow, try those features with non-sensitive material too. Real credentials and private records are not needed to find out where a feature sends information.
Once the models and dependencies are available, try the same task disconnected. If it finishes, you have learned that this task worked under those conditions. You have not established that the connected app never contacts a service, that every feature works offline, or that stored data cannot be sent later.
Network inspection also sees only part of the route. Chrome’s Network panel shows requests for the inspected page, not automatically the calls from a separate backend. Encrypted traffic may reveal a destination without revealing its contents. A team that requires isolation needs enforced, verified outbound-network policy across the actual environment, including tools; a quiet browser tab cannot establish that by itself.
Return to the notes with a deliberate choice
The writer may choose a downloaded model for private notes and accept slower answers or modest hardware. A team may prefer a managed internal service with clear owners for updates, access and backups. A hosted document processor or current web research can also be useful when the material sent there is appropriate.
The choice is now smaller and more understandable than “Is local AI private?” Will these scanned pages be read on the laptop or by an approved outside service? What does the date search receive? Where will the saved conversation go? Include input preparation, tools and retained copies alongside the model, with a purpose and destination for each connection.
The manuscript can remain the writer’s unfinished business without every useful feature having to be offline. Local AI gives more control when the writer knows which work stays nearby and which work they have chosen to send elsewhere.
Historical documentation review: October 28, 2026 (UTC). Product behavior depends on release and configuration. This article explains documented capabilities and illustrative workflows; it does not report hands-on security testing or guarantee isolation.
Sources & context
Sources linked in this article. Read alongside the author’s analysis; a citation does not independently verify a publisher’s claims.
- LM Studio offline operationlmstudio.ai
- Ollama API introductiondocs.ollama.com
- Ollama's embeddings documentationdocs.ollama.com
- Open WebUI offline guidedocs.openwebui.com
- tool-calling guidedocs.ollama.com
- architecture documentationmodelcontextprotocol.io
- LM Studio MCP supportlmstudio.ai
- security guidancemodelcontextprotocol.io
- OWASPgenai.owasp.org
- VS Code telemetry documentationcode.visualstudio.com
- Open WebUI storage guidancedocs.openwebui.com
- Ollama FAQdocs.ollama.com
- Offline-mode scopedocs.openwebui.com
- configuration referencedocs.openwebui.com
- Hugging Face model-loading guidancehuggingface.co
- Ollama API referencegithub.com
- running-models referencedocs.ollama.com
- curl manualcurl.se
- Chrome's network-inspection guidedeveloper.chrome.com
