Configure local AI | TestLookup

Hardware assessment

Ollama is free software that runs AI models on your own machine or server. Before you start, check your machine’s processor, memory, disk space and graphics card memory.

Download time, memory use, response time and how much text a model can take in at once all depend on your machine and the models you choose. TestLookup has published no benchmark. The project does give some sizing guidance:

The contribution guide asks for 8 GB of memory (RAM) for the core services, and 16 GB with the local AI model.
The Makefile holds the project’s build commands. It says the optional 32B model needs 32 GB of RAM or more, or a graphics card with 24 GB.

Use a machine or virtual machine that you can throw away. Leave room for everything that runs: PostgreSQL, MongoDB, Redis, file storage, the backend, the web app, the workers, Ollama and ChromaDB. Write down your hardware and any container limits next to your results.

Start the local model services

You need a copy of the code, which Development setup explains how to get. You also need Docker with Compose v2 or a compatible tool, GNU Make and Bash.

On Windows, use Git Bash or WSL. From your copy of the code, run:

make dev-llm

This command, set out in the Makefile on GitHub, starts TestLookup with its local AI services. Those are Ollama and ChromaDB, a search index. The command builds the app, then downloads the models.

If there’s no settings file yet, the command creates one for development. Check the secrets it generated. Never copy its quick-login settings outside development.

Details: the command starts the local-llm Compose profile and then runs make pull-llm. The settings file is .env.

Model downloads

The download step first checks that the Ollama container is running. Then it waits up to 120 seconds for Ollama to answer, checking 60 times, two seconds apart. Then it downloads three models:

Make variable	Default	What it is
`OLLAMA_SLM_MODEL`	`qwen2.5:7b-instruct`	The small model
`OLLAMA_LLM_MODEL`	`qwen2.5:14b-instruct-q5_K_M`	The large model
`OLLAMA_EMBEDDING_MODEL`	`nomic-embed-text:v1.5`	The embedding model, which turns text into numbers so TestLookup can find similar failures

Separately, one setting in the settings file names the model TestLookup calls by default. Its default is qwen2.5:7b-instruct, the same model as the small one. The project and step settings decide which steps use the small model and which use the large one.

Details: the setting is LLM_MODEL in .env.

When the downloads finish, the output says that the models were downloaded. It then shows the addresses of Ollama and ChromaDB:

http://localhost:11434    Ollama
http://localhost:8001     ChromaDB

Write down the model names that were downloaded. A model named in the Makefile isn’t installed until its download has succeeded.

Optional overrides

To download a different model, add its variable to the make command. For example:

make dev-llm OLLAMA_LLM_MODEL=your-reviewed-tag

The variables for the small model and the embedding model work the same way.

If you change the model TestLookup should call, set the default-model setting to exactly the same name. Then restart TestLookup. The model check matches the exact name.

Details: set LLM_MODEL in .env to exactly the same tag.

Where your model source supports it, use exact model versions. If you’ll move the models to an offline machine, keep their checksums or file lists. A checksum is a short code that proves a file hasn’t changed.

The 32B model isn’t part of the dev-llm command. A separate command downloads it into a running TestLookup that already has the local AI services. It’s about 20 GB:

make pull-llm-large    # downloads qwen2.5:32b-instruct, about 20 GB

Changing which models are installed doesn’t by itself change any of the project’s AI settings. Those are the analysis mode, the model size each step uses, the workflow, the spending limit, tool permissions and the model provider.

Check what TestLookup will really use

TestLookup has four analysis modes:

rules: rule-based analysis, where the same input always gives the same answer;
ml: machine learning, a model trained on your team’s own labels;
llm: an AI language model;
auto: the default.

Which path an analysis really takes also depends on:

the offline setting;
project and step settings;
on and off switches for features;
whether the model provider answers;
the model size;
the spending limit;
the evidence;
the fallback rules.

Details: the setting is ANALYSIS_MODE in .env.

So check, rather than assume.

As a QA lead or administrator, open Settings › AI › AI configuration. It shows which required models are installed and which model sizes will really run. For any missing model, it shows the command to download it.

After an analysis, check the run’s saved record of where the result came from. Ask AI chat stays unavailable while the mode is rules. The AI guide on GitHub describes how TestLookup picks a model, spending limits, review and fallback.

Offline mode and air-gapped installs

Offline mode is on by default. It lets TestLookup call only local or private AI model addresses that pass its checks.

It’s a setting inside TestLookup, not a firewall. A setting under Settings › AI can make it stricter, but it can’t turn offline mode off.

Details: the setting is AI_OFFLINE_MODE=true.

An air-gapped installation runs on a network with no internet connection at all. It must bring everything in beforehand, with checksums:

app and infrastructure images;
dependencies;
model and embedding files;
the contents of your image registry.

The known limitations on GitHub ask you to prove that it works. Start TestLookup on a network that blocks outgoing traffic, then run a typical task from start to finish. A download that worked before you cut the machine off proves nothing about the machine once it’s cut off.

Verification and cleanup

Check that the local models are ready:

List the models that Ollama has downloaded. You should see the three models from the table above.
Terminal window
```
make list-llm
```
Open Settings › AI › AI configuration. It should show the models as installed, and the model sizes that will run.
Send a small report, as in Import your first report, and check its analysis. See which steps ran and which were skipped. Check whether the result came from rules, a trained model or an AI language model. A well-formed result isn’t always a correct one.

Searching by meaning, called semantic search, uses a separate embedding model. By default, every installation starts with ChromaDB’s own MiniLM model, which runs on the processor.

Offline mode blocks downloading the MiniLM files. So an air-gapped installation must copy them into the folder that a setting names.

Without them, search falls back to matching exact words, and it says so. The Ollama embedding model takes effect only after an administrator chooses Re-embed now under Settings › AI.

Details: the folder setting is CHROMA_ONNX_MODEL_DIR.

To stop TestLookup, run the stop command. Your data and downloaded models stay in their storage volumes. The clean command deletes all app and model data, so use it only when you want to start from nothing.

make stop                 # stop, and keep data and models
make clean CONFIRM=yes    # delete all app and model data

What a recorded run showed

This run was recorded on September 21, 2026, with an earlier development version of TestLookup. At that time, the default small model was a different, earlier one.

TestLookup no longer recommends it because of its license. Details may differ on later versions.

Details: the earlier default small model was qwen2.5:3b-instruct-q5_K_M.

The run used Podman 5.8.5 on a Fedora 44 machine under WSL2, running as root. It used Docker Compose provider 5.3.1 and GNU Make 4.4.1.

The machine reported 24 processors and about 15.3 GiB of memory. The fixed container names were removed from temporary copies of the Compose files, to avoid clashes with other local containers.

The local AI services started Ollama 0.5.4 and Chroma 1.5.9. The download step fetched the three models set for that version. The model check reported that Ollama could be reached and that the required models were there.

The saved settings recorded the provider as ollama, the earlier default small model, analysis mode auto, and offline mode set by the environment. A fresh analysis run completed 12 steps, skipped 8 and failed none. The worker logs showed TestLookup choosing the small model and calling Ollama successfully.

Chroma answered its health check, but searches by meaning fell back to exact words. The MiniLM model folder hadn’t been copied in. So installing the Ollama embedding model alone didn’t make search by meaning ready.

Read the AI configuration reference.