Use an Agnos export in Custom GPTs, NotebookLM, AnythingLLM and n8n

Agnos, a Windows app made by Gidion, exports cleaned documents in two shapes that suit these tools: plain text files, one per document, and a RAG corpus, one JSONL file of pieces with the file and pages each came from. This guide says which to use where, what each tool accepts today, and how to upload. It needs no code, apart from an n8n workflow you paste in as it is.

Claude Projects and Copilot are covered in the knowledge files guide.

Which export to choose

The first three are built to take documents: they read each file and do their own searching, so give them whole documents. n8n is a workflow tool: you decide what happens to each piece, so it can use the pieces Agnos already made, with their fields.

• All three accept plain text. .txt is on the lists of OpenAI, Google and AnythingLLM. JSONL is not on Google’s list, and OpenAI’s list of document formats names only DOCX, PDF and TXT.
• A JSONL record holds more than the text. Each line also carries field names, ids and scores. A tool that reads the file as plain text searches all of that too.
• Names carry over. Each text file is named after its document, so an answer that cites a file points to a name you know.

The other two kinds of export are for other jobs: Training data for fine-tuning, and Everything for a full record of the cleaning.

Get the files out of Agnos

1. Clean the documents. In a project with the RAG / Retrieval Corpus purpose, add your files on the Import step, then open Review, choose a file and press Removed to see what was taken out. The quick start walks through it.

2. Build the export. Open Export and choose Cleaned documents for Custom GPTs, NotebookLM and AnythingLLM, or RAG corpus for n8n. Press Build and download.

3. Unzip Cleaned documents. The zip holds one .txt file per document, and manifest.json. Upload the text files. Leave manifest.json out: it records what is in the export, for you rather than for the assistant.

A RAG corpus is a single file, not a zip, with a name like agnos-dataset_20260923_141502.jsonl. Cleaned documents keeps every copy of a passage that appears in two documents. To keep only the first, set Text found in more than one file to Keep one copy before you build. Every file and field is listed in Export formats.

Read the text files before you upload them. Uploading to ChatGPT or Gemini Notebook sends them to OpenAI or Google. Agnos cleans them on your computer, but it does not decide what is safe to share.

Custom GPTs

OpenAI plans to retire custom GPTs on 11 December 2026 and move them to plugins. When a GPT is migrated, its knowledge files are copied into the plugin’s reference files, so files you prepare now carry over (Custom GPT retirement and migration FAQ).

Limits for GPT knowledge files

• Up to 20 files per GPT, each up to 512 MB, according to Creating and editing GPTs. OpenAI’s Uploading files and audio to ChatGPT says 10 knowledge files per GPT in total, for as long as the GPT exists, so check the builder.
• Text and document files are capped at 2 million tokens each (Uploading files and audio to ChatGPT).
• OpenAI says GPTs take most common document, text and code file types, and lists TXT among the document formats ChatGPT reads.
• Personal accounts (Free, Go, Plus and Pro) can no longer create or publish new GPTs. Business, Enterprise and Edu workspaces can, when their settings allow it (Creating and editing GPTs). For affected Enterprise workspaces, creating new GPTs is planned to end on 26 October 2026 (retirement FAQ).
• If you cannot make a GPT, a ChatGPT project takes files too: up to 5 per project on Free, 25 on Go and Plus, and 40 on Edu, Pro, Business and Enterprise (Uploading files and audio to ChatGPT).

Upload knowledge files to a GPT

1. Open the GPT builder. In ChatGPT, open Explore GPTs in the sidebar, or go to chatgpt.com/gpts, and select Create. To change a GPT you made, open My GPTs, choose it and select Edit GPT.

2. Add the files. In the configuration view, under Knowledge, upload the .txt files from the unzipped export.

3. Test and save. Ask a few questions in Preview to check that it answers from the files, then select Create, or Update for a GPT you edited.

If you have more documents than a GPT takes files, you can paste several text files into one, each starting with its document’s name. Agnos does not combine them for you.

NotebookLM

Google renamed NotebookLM to Gemini Notebook in July 2026. It is the same product (Google’s announcement).

Limits for notebook sources

• It takes .txt, .md, .pdf, .docx, .csv and .pptx files, among other sources. JSON and JSONL files are not on the list (Add or discover new sources for your notebook).
• Each source can hold up to 500,000 words, or 200 MB for an uploaded file (the same page).
• A notebook holds up to 50 sources on the free Standard plan, 100 with Google AI Plus, 300 with AI Pro, and 500 or 600 with AI Ultra, depending on the Ultra plan (Learn about Gemini Notebook’s plans).

Add the files as sources

1. Open a notebook. On your computer, open Gemini Notebook. Open a notebook you own, or create one.

2. Add the files. On the left, select Add sources and add the .txt files from the unzipped export.

3. Choose what to ask about. To ask about only some documents, select those sources in the Source panel.

AnythingLLM

AnythingLLM runs as a desktop app, on your own server, or as a hosted cloud instance. When you embed a document, it turns the file into text, cuts the text into chunks and stores them for the workspace to search. The steps below use the labels in AnythingLLM 1.18.0, the current release.

Give it the text files rather than the .jsonl. AnythingLLM reads a file type it has no reader for as plain text, if the file looks like text, so a .jsonl would go in with its field names and ids. Its splitter breaks at paragraphs, lines or spaces to keep chunks within 1,000 characters, so a piece longer than that is cut partway through, with field names and ids mixed in.

Limits for AnythingLLM uploads

• The docs give no list of file types and no size limit for the desktop app or your own server. The upload box says it takes text files, CSVs, spreadsheets, audio and more. Its source code lists the document types: .txt, .md, .org, .adoc, .rst, .html, .csv, .json, .pdf, .docx, .pptx, .xlsx, .odt, .odp, .epub and .mbox (constants.js in 1.18.0).
• On the hosted cloud with the built-in embedder, the size that matters is words, not megabytes. AnythingLLM recommends at most 10,000 words per file on the Starter tier and 50,000 on Professional, or a cloud embedder for larger files (502 Error on AnythingLLM Hosted).
• Chunks are up to 1,000 characters, with 20 characters of overlap, unless you change them in Settings, AI Providers, Text Splitter & Chunking (Text Splitting & Chunking).

Embed the files in a workspace

1. Open the upload panel. In the sidebar, point at the workspace and select its upload icon, the one labelled “Upload documents to this workspace for RAG indexing”.

2. Add the files. Drop the .txt files on Click to upload or drag and drop. AnythingLLM reads them and lists them under My Documents.

3. Move them in. Tick the files and select Move to Workspace.

4. Embed them. Select Save and Embed. Every thread in the workspace can now search them.

You can also drop a file into a chat instead. AnythingLLM then puts its full text into that thread only, and offers to embed it if it is too long for the model (Using Documents in AnythingLLM). AnythingLLM reads uploads on the machine it runs on. What reaches a model depends on the model provider you connect.

n8n

In n8n you decide what happens to each piece: send it to a vector store, a database or a spreadsheet. The workflow below does the step all of those need first. It takes the RAG corpus file and turns each line into one n8n item, with the record’s fields as the item’s fields. It has three nodes:

On form submission (n8n Form Trigger)

Shows a form with one file field, for the .jsonl file. Its field name is data, so the file arrives in the binary field data.

Extract from File

Extract From Text File reads that file as UTF-8 into one text field, also named data.

One item per record (Code)

Four lines of JavaScript split the text at line breaks, skip empty lines, and read each line as JSON.

The whole workflow, ready to paste:

{
  "name": "Agnos RAG corpus to items",
  "nodes": [
    {
      "parameters": {
        "formTitle": "Agnos RAG corpus",
        "formDescription": "Choose the .jsonl file that Agnos exported.",
        "formFields": {
          "values": [
            {
              "fieldLabel": "RAG corpus (.jsonl)",
              "fieldName": "data",
              "fieldType": "file",
              "multipleFiles": false,
              "acceptFileTypes": ".jsonl",
              "requiredField": true
            }
          ]
        },
        "options": {}
      },
      "id": "e39c1eec-f2e7-4c4b-b525-ca657ba1264f",
      "name": "On form submission",
      "type": "n8n-nodes-base.formTrigger",
      "typeVersion": 2.6,
      "position": [0, 0],
      "webhookId": "b9ade1f8-0e72-4ab8-afa1-4d9e33775f2d"
    },
    {
      "parameters": {
        "operation": "text",
        "binaryPropertyName": "data",
        "destinationKey": "data",
        "options": {
          "encoding": "utf8"
        }
      },
      "id": "047a6eda-4199-42a4-aefc-d152ab144e8e",
      "name": "Extract from File",
      "type": "n8n-nodes-base.extractFromFile",
      "typeVersion": 1.1,
      "position": [220, 0]
    },
    {
      "parameters": {
        "jsCode": "// One n8n item for each line of the .jsonl file\nconst text = $input.first().json.data;\nconst lines = text.split(/\\r?\\n/).filter((line) => line.trim() !== '');\nreturn lines.map((line) => ({ json: JSON.parse(line) }));"
      },
      "id": "04fc915e-3380-48ac-9255-a060be5afa96",
      "name": "One item per record",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [440, 0]
    }
  ],
  "connections": {
    "On form submission": {
      "main": [[{ "node": "Extract from File", "type": "main", "index": 0 }]]
    },
    "Extract from File": {
      "main": [[{ "node": "One item per record", "type": "main", "index": 0 }]]
    }
  },
  "settings": {
    "executionOrder": "v1",
    "binaryMode": "separate"
  }
}

The Code node holds this JavaScript, written out on four lines:

// One n8n item for each line of the .jsonl file
const text = $input.first().json.data;
const lines = text.split(/\r?\n/).filter((line) => line.trim() !== '');
return lines.map((line) => ({ json: JSON.parse(line) }));

Import and run the workflow

1. Import it. Copy the JSON. In n8n, open a new workflow and paste it onto the canvas with Ctrl+V. Or save it as a .json file, open the workflow menu (the three dots) and choose Import, then From file (Export and import).

2. Run it. Select Execute workflow. n8n opens the form at its test URL.

3. Send the file. Choose the .jsonl file Agnos exported and submit the form.

4. Check the items. Open One item per record. There is one item for each line of the file.

In the node you add next, map the fields with expressions: {{ $json.text }} for the passage, and {{ $json.source }}, {{ $json.page_start }} or {{ $json.chunk_id }} for where it came from.

The result for the handbook

The handbook PDF from the other guides is short, so its RAG corpus is one line (download it, 1.5 KB), and the workflow gives one item. A longer export gives one item per line. Given that file the way Extract from File passes it on, the Code node’s JavaScript returned this, with the text shortened:

[
  {
    "json": {
      "text": "Northwind Tools Staff Handbook\nThis handbook covers … nobody keeps a copy after\nleaving.",
      "chunk_id": "d733867d65aa37daf2259108e3323ff6_000000",
      "source": "northwind-staff-handbook.pdf",
      "file_id": 1,
      "uploaded_at": "2026-09-23T23:02:03.677203Z",
      "quality_score": 0.8541,
      "language_confidence": 0,
      "content_type": "prose",
      "chunk_index": 0,
      "page_start": 1,
      "page_end": 4
    }
  }
]

The headers, footers and page numbers are already out of text, and the pages it came from are kept as fields. What each field means is in Export formats.

Limits for n8n

• A self-hosted n8n takes form uploads of up to 200 MiB per file by default. N8N_FORMDATA_FILE_SIZE_MAX changes it (Endpoints environment variables).
• On n8n Cloud, memory is the limit to watch, because the workflow holds the whole file as one text: 640 MiB on the Trial, Starter and Pro-1 plans, 1,280 MiB on Pro-2 and 4,096 MiB on Enterprise (Manage your data). n8n itself uses about 180 MiB of that. The Code node can increase memory use significantly (Fix memory issues). n8n also advises against manual executions for large amounts of data, so for a large file, publish the workflow and use the form’s production URL.

Worth knowing in n8n

• Use Extract From Text File, not Extract From JSON. Extract From JSON reads the whole file as one JSON value. That happens to work on the one-line handbook file, but a file of several lines stops with an error.
• On your own server, you can read the file from disk. Replace the form with Read/Write Files from Disk, whose output field is also data. Since n8n 2.0 it reads only from ~/.n8n-files unless N8N_RESTRICT_FILE_ACCESS_TO says otherwise, and in Docker the path is inside the container. On n8n Cloud it reads only under /home/node/, and files there are not guaranteed to last between runs, so keep the form (Read/Write Files from Disk).
• Keep the names in step. If you change the form field’s name from data, change Input Binary Field in Extract from File to match.
• Windows line endings are fine. The Code node splits at either kind of line break and skips blank lines.

How this guide was checked

• Each tool’s limits come from its own help pages and docs, read on 17 October 2026. They change, so check the linked page before you plan around a number.
• The AnythingLLM labels and file types come from the source code of AnythingLLM 1.18.0, released on 13 October 2026.
• The n8n workflow was checked against n8n 2.43.7, the stable release on 17 October 2026: its node types, node versions and parameters against n8n’s docs and source code. n8n itself was not run, so this is a check against the docs, not a test run.
• The Code node’s JavaScript was run for real with Node.js 24.14.0 (n8n 2.43.7 needs Node.js 24 or later) on the handbook export above, and printed the output shown. The same run on a three-line file with Windows line endings gave three items. The workflow JSON was checked by a script in Python 3.14.3, with no packages installed.