Share a local LLM script with your team summarize or extract data from documents with Ollama on your computer

You can share a local Ollama script by wrapping it in a web form with Button (https://button.bitgate.dev), which relays files and form inputs from a coworker's browser to the script on your computer. Each run can take up to 30 minutes and accept files up to 25 MB each, and the Free plan ($0) includes 1 published tool for up to 3 people and 100 runs per month. If your coworkers want an open-ended chat interface instead of a fixed document task, use Open WebUI rather than Button.

When to use Open WebUI vs. a Button form

If your team wants to chat with a model, write their own prompts and go back and forth, install Open WebUI. Open WebUI is a self-hosted chat interface for Ollama and OpenAI-compatible APIs.

Button is for the other case: when you have one specific job - like summarizing a PDF into a fixed template or pulling fields out of documents into a CSV - and you already wrote a script that calls Ollama's local REST API at http://localhost:11434. Instead of giving people a chat box, you give them a web form with a file upload and a Run button.

With Button, the job still runs on your computer, never in Button's cloud. Button's servers relay the form values and files between your colleague's browser and your machine, your script talks to your local Ollama instance, and your colleague downloads the output file when it finishes. They don't install anything and they never pay.

Prepare your script for command-line arguments

Before you connect your script to Button, make sure it takes its inputs as command-line arguments instead of using hard-coded file paths or interactive prompts. Any program works: Python, Node, R, PowerShell, shell scripts, compiled binaries. You can use argparse in Python, commandArgs() in R, a param() block in PowerShell, or $1 and $2 in bash.

Take each input file path as an argument, and write the results as files into an output folder that is also passed in as an argument. Fixed flags such as --task are part of the command you approve on your machine; your colleagues only supply the values for the form fields.

Here is a minimal Python pattern that takes a text file, one of three fixed tasks and an output directory, calls Ollama at http://localhost:11434, and writes the result to a text file. Ollama uses a 4,096-token context window by default, so the request raises num_ctx for longer documents; larger values need more memory:

import argparse
import json
import pathlib
import urllib.request

PROMPTS = {
    "summary": "Summarize this document in five bullet points.",
    "action-items": "List every action item in this document with its owner and due date.",
    "dates": "List every date in this document and what happens on it.",
}

parser = argparse.ArgumentParser()
parser.add_argument("--task", choices=list(PROMPTS), required=True)
parser.add_argument("--input", required=True)
parser.add_argument("--outdir", required=True)
args = parser.parse_args()

text = pathlib.Path(args.input).read_text(encoding="utf-8", errors="ignore")
payload = json.dumps({
    "model": "llama3.2",
    "prompt": f"{PROMPTS[args.task]}\n\nDocument:\n{text}",
    "stream": False,
    "options": {"num_ctx": 16384},
}).encode("utf-8")

request = urllib.request.Request(
    "http://localhost:11434/api/generate",
    data=payload,
    headers={"Content-Type": "application/json"},
)
with urllib.request.urlopen(request) as response:
    result = json.loads(response.read())["response"]

(pathlib.Path(args.outdir) / f"{args.task}.txt").write_text(result, encoding="utf-8")

For PDFs, extract the text first (for example with pypdf) and pass it in the same way. For structured output, ask the model for JSON and write rows to a CSV in the output directory.

Put a Button form in front of the script

Once the script runs cleanly from your terminal, setting it up on Button takes a few steps:

1. Keep Ollama running locally on your computer so http://localhost:11434 is reachable by your script.
2. Sign in at https://button.bitgate.dev.
3. Install the Button runner on your computer (macOS, Linux or Windows) using the one-line command the site shows you - it's a curl command on macOS and Linux, and PowerShell on Windows.
4. Open the local setup page, pick your script, and describe its inputs: a choice field for the task (summary, action-items, dates) and a file field for the document. Button also supports text, number and yes/no fields.
5. Publish the tool. Button gives it its own web page, and you can invite your colleagues by email.

When a colleague clicks the link in their invite email, they sign in with Google or a one-time email code, fill in the form, press Run and download the results when the script finishes.

How execution and security work

The runner on your computer only executes the exact command you approved on that computer, pinned by hash. Every form value a colleague submits is passed to your program as its own argument, with no shell, and a value can't start with - (so nobody can pass an unexpected flag through a form field). If you change a tool, people have to confirm the new version before running it.

Every run is logged with who ran it and when. And if someone leaves the team or only needs the tool for a week, you can revoke their access or set it to expire at any time.

Limits and pricing

Because Ollama and the Button runner both run on your hardware, your computer has to be on and online when people use the tool. Tool pages show Ready, Busy or Offline so your team knows what's going on, and the runner executes one run at a time per computer.

Recipients never pay on either plan, and downgrading from Pro to Free deletes nothing. Every plan allows one computer (runner) per workspace; pairing a new computer replaces the previous one.

FAQ

Does our document data stay only on my computer?

No. While the script and Ollama run on your computer and never in Button's cloud, Button's servers relay the form values and files between your colleague's browser and your computer. Inputs are deleted 24 hours after a run ends, and outputs are deleted after 7 days.

What happens if two colleagues click Run at the same time?

Button runs one job at a time per computer, and each run can take up to 30 minutes. While a job is running, the tool page shows Busy, and if your computer is asleep or disconnected, the page shows Offline.

Do my colleagues need to install Ollama, Python or the Button runner?

No, they install nothing and never pay. They just open the link from their invite email, sign in with Google or a one-time email code, fill out the form in their browser and download the output files.

Can I connect more than one computer to handle more Ollama runs?

No, each workspace supports one computer (runner) on both the Free and Pro plans. If you pair a new computer with your workspace, it replaces the previous one.