Early November updates: lower prices, Terraform and RAG from GitHub

Over the November 7–8 weekend, we cut prices substantially and added two tools to help you turn an idea into an application with less setup: a Terraform provider for QDivZero and a GitHub Action that sends your Markdown documents to Retrieval.

These updates work together: model calls cost less, keeping a knowledge base costs less, and you can manage infrastructure and document syncing from your repository.

Model prices drop by up to 95.5%

The public API has new input and output rates. Here are some of the reductions, in euros per million tokens:

That means 95.5% lower input pricing for Qwen 3.8 27B, around 93.7% lower input and output pricing for DeepSeek V4.1 Flash, and half-price input and output for GPT-6 Luna and GPT-6 Sol. We have also reduced rates for GLM 5.3 and DeepSeek V4.1 Flash 1017.

For example, processing 10 million tokens with DeepSeek V4.1 Flash, with 90% input and 10% output, drops from around €6.34 to €0.40 on pay-as-you-go billing. Current rates were checked on November 9, 2026 against the public endpoint catalogue; amounts and percentages are rounded. See the current prices and the full price-cut breakdown.

The improvement also reaches Unlimited Basic, which stays at €14.95/month including VAT: both Qwen models remain unlimited, subject to fair use, and the 5,000 monthly AI Credits cover up to 13.6 times more tokens with DeepSeek V4.1 Flash. Subscription credits and euro balance are managed separately; the table above shows pay-as-you-go rates.

Retrieval drops to €0.20/GB per month

We have also lowered the cost of storing your knowledge in QDivZero Retrieval. The rate changes from €0.001/GB per hour to €0.20/GB per month, based on storage usage and duration.

To compare the units, keeping 1 GB for 30 days used to cost €0.72. The new monthly reference is €0.20 per GB, approximately 72.2% less than that 30-day period. Storing 10 GB for a month now has a storage cost of €2.

Embedding generation is billed separately at your chosen model's rate. If your RAG application generates answers with a chat model, that usage has its own cost. See the Retrieval billing details and model prices to estimate the cost of your application.

Manage your QDivZero infrastructure with Terraform

The QDivZero provider is now available in Terraform Registry. You can declare inference instances, scheduled start, stop or scaling rules, vector databases, target groups and Smart Balancers. Data sources also let you discover GPUs and existing serving endpoints.

For a RAG application, start by declaring your Retrieval database. This example uses provider version 0.0.2 and an embedding endpoint you already have available:

1terraform {
2  required_providers {
3    qdivzero = {
4      source  = "QDivZero/qdivzero"
5      version = "0.0.2"
6    }
7  }
8}
9
10provider "qdivzero" {}
11
12variable "embedding_serving_name" {
13  type        = string
14  description = "Name of your compatible embedding endpoint"
15}
16
17resource "qdivzero_vector_database" "knowledge" {
18  name                   = "Company knowledge"
19  slug                   = "company-knowledge"
20  embedding_serving_name = var.embedding_serving_name
21}
22

The provider reads your key from the QDIVZERO_API_KEY environment variable. Set it in your terminal or CI secrets, run terraform init and supply embedding_serving_name. Review changes with terraform plan before applying them with terraform apply. The vector database reference describes the available fields.

You can review infrastructure changes alongside your code and repeat the configuration across environments.

From repository Markdown to Retrieval with GitHub Actions

The new QDivZero Sync Retrieval action syncs .md files tracked by Git into a Retrieval database. Use your repository for policies, product documentation, internal processes or frequently asked questions.

Save your QDivZero account API key as a repository secret named QDIVZERO_API_KEY. You need an existing Retrieval database and its embedding endpoint available during indexing. Then add this file as .github/workflows/sync-retrieval.yml:

1name: Sync knowledge to QDivZero Retrieval
2
3on:
4  push:
5    branches: [main]
6    paths:
7      - "**/*.md"
8  workflow_dispatch:
9
10permissions:
11  contents: read
12
13concurrency:
14  group: qdivzero-retrieval-${{ github.repository }}
15  cancel-in-progress: false
16
17jobs:
18  sync:
19    runs-on: ubuntu-latest
20    steps:
21      - uses: actions/checkout@v7
22      - uses: QDivZero/qdivzero-gha-sync-retrieval@v2.0.0
23        with:
24          api-key: ${{ secrets.QDIVZERO_API_KEY }}
25          database-slug: company-knowledge
26

Change main if you use a different default branch and replace company-knowledge with your database slug. Run the workflow once from Actions → Run workflow. From then on, pushes that change Markdown trigger syncing, and you can check indexed documents in the run summary.

The action sends each file as a document, and the API splits it into overlapping chunks. Re-indexing the same document replaces its previous chunks. You can select content with paths and exclude, adjust chunk sizes and enable cleanup of deleted documents with prune when your API supports it. Cleanup is off by default. Use a separate database per repository and branch to avoid collisions between documents with the same path.

Get a RAG application running quickly

With those pieces, the workflow is:

1. Create your knowledge base, through Terraform or the platform, and connect it to a compatible embedding endpoint.
2. Sync your documents with the GitHub Action and check that a search retrieves the expected passages.
3. Enable Retrieval as a managed tool for your chat model: QDivZero executes the searches requested by the model and provides the results for its answer.

Connect your RAG application with a QDivZero managed tool

Once your database is indexed, add flexible_vector_database_search to the tools array of a request to /v1/chat/completions. The vector_database field takes the database slug, the same company-knowledge used in Terraform and the GitHub Action.

Set QDIVZERO_API_KEY on your server or in your terminal to an account key with access to that database and inference. Replace my-model with the identifier of an available model that supports tools, then try a question about your documents:

1curl --fail-with-body \
2  --request POST "https://api.qdiv0.com/v1/chat/completions" \
3  -H "Authorization: Bearer $QDIVZERO_API_KEY" \
4  -H "Content-Type: application/json" \
5  --data '{
6    "model": "my-model",
7    "messages": [
8      {
9        "role": "system",
10        "content": "Search the knowledge base before answering questions about the company. Base your answer on retrieved documents and cite their sources when available. State when information is missing."
11      },
12      {
13        "role": "user",
14        "content": "What is our returns policy?"
15      }
16    ],
17    "tools": [
18      {
19        "type": "flexible_vector_database_search",
20        "vector_database": "company-knowledge",
21        "allow_write": false,
22        "description": "Search company documentation to answer questions about policies, products and internal processes."
23      }
24    ]
25  }'
26

QDivZero manages tool execution within inference. When the model requests a search, the platform queries Retrieval and returns the passages to the model so it can continue to produce an answer. Your application receives the Chat Completions response and can display the text in choices[0].message.content.

The description tells the model when to use that database. With allow_write: false, the tool only allows searching; documents are maintained through the GitHub Action. Check results against known questions and verify that cited sources support the answers. The embedding endpoint must also be available during search.

See the inference tools documentation for the fields and examples using Chat Completions and Responses. To explore separate search and inference requests as well, follow the guide to building a RAG assistant with your company knowledge.

Lower token costs, lower storage costs and less work to keep your documents connected. Open QDivZero and try the workflow with a question your team gets every week.