---
title: "Crop image anomaly check against a Qdrant collection"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/a43cb346-0556-4820-a3a8-69897c3d3709"
updated: "2026-11-12"
---

# Crop image anomaly check against a Qdrant collection

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow that checks whether an image shows a crop your Qdrant collection knows. Voyage AI embeds the picture, and a short text names the closest crop or raises an alert.

Crop image anomaly check against a Qdrant collection is an n8n workflow in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow checks whether a picture shows a crop that a Qdrant collection already knows. You give it one image address. Voyage AI turns the picture into a vector, and Qdrant returns the stored centre point of each crop that sits closest to it. The workflow compares each score with that crop’s own threshold. It answers that the picture looks like a named crop, or it raises an alert when the picture matches none of the stored crops closely enough to count as known. The answer is one line. Nine nodes run it, beside seven sticky notes.

### Who it suits

Developers and data teams who keep image vectors in Qdrant and want a quick outlier check on new pictures, or a tool that an AI agent can call to screen field photos. Skip it if you have no collection yet. The workflow only reads one, and its layout is set out below.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Agriculture | Agronomy data teams | Flag photos that match none of the crops they track | A team sends a new field photo and gets an alert when it fits no known crop. |
| Quality control | Dataset curators | Screen new uploads before they join a training set | A curator checks each batch and removes the pictures that raise an alert. |
| Software | Developers of AI agents | Give an agent a tool that says whether an image is known | An agent calls the workflow with an image address and reads the answer. |
| Research | Machine learning researchers | Try anomaly rules on image vectors | A researcher compares two threshold settings on the same pictures. |

You need some n8n and a Qdrant collection laid out as described below, plus two credentials.

### Where to use it

Any n8n that can reach Voyage AI and your Qdrant will run it. It is a tool workflow, so another workflow or an agent calls it with an image address. It has no web address of its own.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file and steps
- An AI agent: add this workflow as a Workflow tool and let the agent send the image address
- Another workflow: call it with an Execute Workflow node

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Import the file, add the two credentials, set your Qdrant address and test it with one image address.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| Qdrant | A collection named \`agricultural-crops\` with a vector called \`voyage\`, a \`crop\_name\` field and one marked centre point per crop |
| Voyage AI | An API key |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. Save it.
2. Add a Header Auth credential for Voyage with the name `Authorization` and the value `Bearer <YOUR_VOYAGE_API_KEY>`. Select it in `Embed image`.
3. Add a Qdrant API credential. Select it in `Total Points in Collection`, `Each Crop Counts` and `Get similarity of medoids`.
4. In `Variables for medoids`, replace `<YOUR_QDRANT_URL>` with your cluster’s address.
5. In the same node, check the collection name and the two centre field names.
6. Pin `{ "query": { "imageURL": "<YOUR_IMAGE_URL>" } }` on `Execute Workflow Trigger`, with the address of a real picture, and press Test workflow.

### How to use it

Call the workflow with an image address in a field named `query.imageURL`. It counts the crops in the collection, embeds the picture and asks Qdrant for the closest centre points. Read the answer in the last node. Test with a known crop first.

What to change for a different result

| To change | Where |
| --- | --- |
| The wording of the two answers | \`Compare scores\` |
| The collection and its centre fields | \`Variables for medoids\` |
| The embedding model | \`Embed image\`, after you rebuild the collection with it |
| Where the address comes from | \`Image URL from input\` |

### Example

A data team keeps pictures of many crops in Qdrant, with a centre point and a threshold for each. A new photo arrives from the field, and a script sends its address to this workflow.

If the photo scores above the threshold of any crop, the answer reads `Looks similar to` followed by the best match. If it clears none of them, the answer reads `ALERT, we might have a new undefined crop!`. Use the alert as a prompt to look at the picture. A wrong threshold can mislabel an odd photo as a known crop.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. A vector is a list of numbers that stands for a picture, and pictures that look alike get vectors that sit close together. Qdrant stores those vectors and finds the closest ones. That is all the matching there is.

**For experts.** The check is nearest centre with a per crop threshold, so the thresholds in the collection decide how strict it is.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Each Crop Counts\` | Asks Qdrant for the values of \`crop\_name\` with their counts | The number of distinct crops sets how many centre points the later query returns |
| \`Embed image\` | Posts the image address to Voyage’s multimodal embeddings | The model is \`voyage-multimodal-3\`, and the input type is \`document\` |
| \`Get similarity of medoids\` | Queries the \`voyage\` vector, only among points marked as centres | It returns one point per crop, so each crop needs exactly one centre |
| \`Compare scores\` | Compares each score with the threshold stored on its point | JavaScript in Mindket’s copy, with the same logic as the original |

### Good to know

The workflow needs a collection you build yourself, and its thresholds decide how strict it is. It only reads that collection and never writes to it.

- The collection: the author made it in two earlier pipelines that are not in this file. The layout is in Mindket’s notes: the name, the \`voyage\` vector, \`crop\_name\`, \`is\_medoid\` and the threshold field
- Embedding model: Voyage’s reference, read on 12 November 2026, lists \`voyage-multimodal-3.5\` and \`voyage-multimodal-3\` as recommended. The file keeps the older one, because the stored vectors must come from the same model
- Image addresses: since 8 December 2025 Voyage limits redirects, requires a content-length header and respects robots.txt for image addresses. An image can be at most 20 MB and 16 million pixels
- Repairs: the Qdrant address of the original copy was its author’s own cluster. Its Python step used names that n8n 2 no longer offers, so Mindket’s copy runs the same logic in JavaScript
- Not a diagnosis: the answer only says a picture looks like a known crop or does not
- Billing: Voyage bills each embedding, and Qdrant bills by your plan
- Your data: the image address goes to Voyage, which fetches the picture, and Qdrant receives the vector
- Credentials: the JSON holds none

## README

```markdown
# Crop image anomaly check against a Qdrant collection

An n8n workflow that takes the address of one image and says whether it shows a crop your collection already knows. It
turns the picture into a vector with Voyage AI, compares that vector with one centre point per crop in a Qdrant
collection, and answers with a short text. If the picture matches no crop closely enough, the text raises an alert.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 9 nodes and 7 sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The Qdrant address was the author's own cluster. `Variables for medoids` now holds `<YOUR_QDRANT_URL>`.
- `Compare scores` was a Python Code node that read `_input` and `_()`. n8n's documentation says Pyodide, which provided
  those names, is removed from n8n 2.0, and that native Python there offers only `_items` and `_item`, with no imports by
  default. Mindket's copy holds the same logic written in JavaScript, which runs on every n8n version.
- The node `Image URL hardcode` hardcoded nothing: it reads `query.imageURL` from the call. It is now called
  `Image URL from input`, and `Embed image` points at the new name.
- Two sticky notes that pointed at the author's other pipelines and pages are gone, and the one beside the three counting
  nodes now says what they do. The others keep their text.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A Qdrant collection built for this check, described next. The workflow only reads it.
- A Voyage AI API key.
- Your Qdrant address and, if the cluster asks for one, its API key.

## The collection it expects

The workflow does not build the collection. The author made it in two earlier pipelines that are not in this file, so you
need your own. It must look like this:

- The collection name is `agricultural-crops`. Change it in `Variables for medoids` if yours differs.
- It has a named vector called `voyage`, filled with Voyage multimodal embeddings of crop pictures made with
  `voyage-multimodal-3`.
- Every point has a `crop_name` payload field with the crop's name.
- One point per crop is marked as its centre: `is_medoid` is `true`, and `is_medoid_cluster_threshold` holds a number.
  That number is the lowest similarity score at which a picture still counts as that crop.
- A second set of centres, named by text, may use `is_text_anchor_medoid` and `is_text_anchor_medoid_cluster_threshold`.
  To use it, put those two names in `Variables for medoids`.

The workflow counts the crop names in the collection, and it asks Qdrant for that many centre points.

## Set it up

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. Save it.
2. Add a Header Auth credential for Voyage with the name `Authorization` and the value `Bearer <YOUR_VOYAGE_API_KEY>`.
   Select it in `Embed image`.
3. Add a Qdrant API credential with your address and key. Select it in `Total Points in Collection`,
   `Each Crop Counts` and `Get similarity of medoids`.
4. In `Variables for medoids`, replace `<YOUR_QDRANT_URL>` with your cluster's address, without a slash at the end.
5. In the same node, check that the collection name and the centre field names match your collection.
6. To test it by hand, pin this item on `Execute Workflow Trigger` and press Test workflow:
   `{ "query": { "imageURL": "<YOUR_IMAGE_URL>" } }`
   Use the address of a real picture. To use it as a tool, call this workflow through an agent's Workflow tool, which passes
   the address in the same `query` field.

## How a run goes

1. `Execute Workflow Trigger` receives the call.
2. `Image URL from input` copies `query.imageURL` into a field called `imageURL`.
3. `Variables for medoids` sets the Qdrant address, the collection name and the two centre field names.
4. `Total Points in Collection` asks Qdrant for an exact count of the points. `Each Crop Counts` asks for the values of
   `crop_name` with their counts, and `Info About Crop Labeled Clusters` keeps how many crops there are.
5. `Embed image` sends the picture's address to Voyage's multimodal embeddings with the model `voyage-multimodal-3`,
   and gets a vector back.
6. `Get similarity of medoids` queries Qdrant with that vector against the `voyage` vector, only among the points marked
   as centres, and asks for one result per crop.
7. `Compare scores` checks each result against its own threshold. If at least one reaches it, the answer is
   `Looks similar to <crop>`, with the crop of the highest score. If none does, the answer is
   `ALERT, we might have a new undefined crop!`.

## Change the look

- The wording of the two answers: `Compare scores`.
- The collection and the centre fields: `Variables for medoids`.
- The embedding model: `Embed image`. A new model makes vectors that do not fit the stored ones, so rebuild the
  collection with the same model first.
- Where it gets the address: change `Image URL from input` to read another field.

## Good to know

- The facts below come from pages and n8n documents read on 12 November 2026.
- Voyage's reference lists `voyage-multimodal-3.5` and `voyage-multimodal-3` as its recommended multimodal models. The
  file keeps the older one, since the collection's vectors must come from the same model.
- Since 8 December 2025 Voyage limits the redirects it follows for an image address, requires a content-length header
  and respects robots.txt. An address that fails any of these makes the embedding call fail. An image can be at most 20
  MB and 16 million pixels.
- With a threshold you set too low, the check calls an odd picture a known crop. Set each threshold against pictures you
  know are not in the collection.
- The answer says only that a picture looks like a known crop or does not. It is a screening aid, not a diagnosis.
- Billing: Voyage bills each embedding, and Qdrant Cloud bills according to your plan.
- Your data: the picture's address goes to Voyage, and Voyage fetches the picture itself. Qdrant receives the vector.
- Credentials: the JSON holds none.
```

## What is in it

3 files, 19 KB, downloaded as a zip.

```text
NOTICE.md  669 B
README.md  6 KB
workflow.json  12 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 9 steps, starting when another workflow calls it
- AI: No step calls an AI model
- Sign-ins: Signs in to: Qdrant and api.voyageai.com
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 4 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/a43cb346-0556-4820-a3a8-69897c3d3709)
- [Its page on Mindket](https://mindket.com/p/a43cb346-0556-4820-a3a8-69897c3d3709)
